home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Dev / gcc263-src.lha / gcc-2.6.3 / cp / parse.y < prev    next >
Text File  |  1994-11-18  |  110KB  |  3,814 lines
  1. /* YACC parser for C++ syntax.
  2.    Copyright (C) 1988, 1989, 1993 Free Software Foundation, Inc.
  3.    Hacked by Michael Tiemann (tiemann@cygnus.com)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. /* This grammar is based on the GNU CC grammar.  */
  23.  
  24. /* Note: Bison automatically applies a default action of "$$ = $1" for
  25.    all derivations; this is applied before the explicit action, if one
  26.    is given.  Keep this in mind when reading the actions.  */
  27.  
  28. /* Also note: this version contains experimental exception
  29.    handling features.  They could break, change, disappear,
  30.    or otherwise exhibit volatile behavior.  Don't depend on
  31.    me (Michael Tiemann) to protect you from any negative impact
  32.    this may have on your professional, personal, or spiritual life.
  33.  
  34.    NEWS FLASH:  This version now supports the exception handling
  35.    syntax of Stroustrup's 2nd edition, if -fansi-exceptions is given.
  36.    THIS IS WORK IN PROGRESS!!!  The type of the 'throw' and the
  37.    'catch' much match EXACTLY (no inheritance support or coercions).
  38.    Also, throw-specifications of functions don't work.
  39.    Destructors aren't called correctly.  Etc, etc.  --Per Bothner.
  40.   */
  41.  
  42. %{
  43. /* Cause the `yydebug' variable to be defined.  */
  44. #define YYDEBUG 1
  45.  
  46. #include "config.h"
  47.  
  48. #include <stdio.h>
  49. #include <errno.h>
  50.  
  51. #include "tree.h"
  52. #include "input.h"
  53. #include "flags.h"
  54. #include "lex.h"
  55. #include "cp-tree.h"
  56.  
  57. /* Since parsers are distinct for each language, put the language string
  58.    definition here.  (fnf) */
  59. char *language_string = "GNU C++";
  60.  
  61. extern tree void_list_node;
  62. extern struct obstack permanent_obstack;
  63.  
  64. #ifndef errno
  65. extern int errno;
  66. #endif
  67.  
  68. extern int end_of_file;
  69. extern int current_class_depth;
  70.  
  71. void yyerror ();
  72.  
  73. /* Like YYERROR but do call yyerror.  */
  74. #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
  75.  
  76. #define OP0(NODE) (TREE_OPERAND (NODE, 0))
  77. #define OP1(NODE) (TREE_OPERAND (NODE, 1))
  78.  
  79. /* Contains the statement keyword (if/while/do) to include in an
  80.    error message if the user supplies an empty conditional expression.  */
  81. static char *cond_stmt_keyword;
  82.  
  83. /* Nonzero if we have an `extern "C"' acting as an extern specifier.  */
  84. int have_extern_spec;
  85. int used_extern_spec;
  86.  
  87. void yyhook ();
  88.  
  89. /* Cons up an empty parameter list.  */
  90. #ifdef __GNUC__
  91. __inline
  92. #endif
  93. static tree
  94. empty_parms ()
  95. {
  96.   tree parms;
  97.  
  98.   if (strict_prototype)
  99.     parms = void_list_node;
  100.   else
  101.     parms = NULL_TREE;
  102.   return parms;
  103. }
  104. %}
  105.  
  106. %start program
  107.  
  108. %union {long itype; tree ttype; char *strtype; enum tree_code code; }
  109.  
  110. /* All identifiers that are not reserved words
  111.    and are not declared typedefs in the current block */
  112. %token IDENTIFIER
  113.  
  114. /* All identifiers that are declared typedefs in the current block.
  115.    In some contexts, they are treated just like IDENTIFIER,
  116.    but they can also serve as typespecs in declarations.  */
  117. %token TYPENAME
  118.  
  119. /* Reserved words that specify storage class.
  120.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
  121. %token SCSPEC
  122.  
  123. /* Reserved words that specify type.
  124.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
  125. %token TYPESPEC
  126.  
  127. /* Reserved words that qualify type: "const" or "volatile".
  128.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
  129. %token TYPE_QUAL
  130.  
  131. /* Character or numeric constants.
  132.    yylval is the node for the constant.  */
  133. %token CONSTANT
  134.  
  135. /* String constants in raw form.
  136.    yylval is a STRING_CST node.  */
  137. %token STRING
  138.  
  139. /* "...", used for functions with variable arglists.  */
  140. %token ELLIPSIS
  141.  
  142. /* the reserved words */
  143. /* SCO include files test "ASM", so use something else. */
  144. %token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
  145. %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD GCC_ASM_KEYWORD TYPEOF ALIGNOF
  146. %token HEADOF CLASSOF SIGOF
  147. %token ATTRIBUTE EXTENSION LABEL
  148.  
  149. /* the reserved words... C++ extensions */
  150. %token <ttype> AGGR
  151. %token <itype> VISSPEC
  152. %token DELETE NEW OVERLOAD THIS OPERATOR CXX_TRUE CXX_FALSE
  153. %token LEFT_RIGHT TEMPLATE
  154. %token TYPEID DYNAMIC_CAST STATIC_CAST REINTERPRET_CAST CONST_CAST
  155. %token <itype> SCOPE
  156.  
  157. /* Define the operator tokens and their precedences.
  158.    The value is an integer because, if used, it is the tree code
  159.    to use in the expression made from the operator.  */
  160.  
  161. %left EMPTY            /* used to resolve s/r with epsilon */
  162.  
  163. %left error
  164.  
  165. /* Add precedence rules to solve dangling else s/r conflict */
  166. %nonassoc IF
  167. %nonassoc ELSE
  168.  
  169. %left IDENTIFIER TYPENAME PTYPENAME SCSPEC TYPESPEC TYPE_QUAL ENUM AGGR ELLIPSIS TYPEOF SIGOF OPERATOR
  170.  
  171. %left '{' ',' ';'
  172.  
  173. %right <code> ASSIGN '='
  174. %right <code> '?' ':'
  175. %left <code> OROR
  176. %left <code> ANDAND
  177. %left <code> '|'
  178. %left <code> '^'
  179. %left <code> '&'
  180. %left <code> MIN_MAX
  181. %left <code> EQCOMPARE
  182. %left <code> ARITHCOMPARE '<' '>'
  183. %left <code> LSHIFT RSHIFT
  184. %left <code> '+' '-'
  185. %left <code> '*' '/' '%'
  186. %left <code> POINTSAT_STAR DOT_STAR
  187. %right <code> UNARY PLUSPLUS MINUSMINUS '~'
  188. %left HYPERUNARY
  189. %left <ttype> PAREN_STAR_PAREN LEFT_RIGHT
  190. %left <code> POINTSAT '.' '(' '['
  191.  
  192. %right SCOPE            /* C++ extension */
  193. %nonassoc NEW DELETE TRY CATCH THROW
  194.  
  195. %type <code> unop
  196.  
  197. %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist
  198. %type <ttype> paren_expr_or_null nontrivial_exprlist
  199. %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
  200. %type <ttype> typed_declspecs reserved_declspecs boolean.literal
  201. %type <ttype> typed_typespecs reserved_typespecquals
  202. %type <ttype> declmods typespec typespecqual_reserved
  203. %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
  204. %type <itype> initdecls notype_initdecls initdcl    /* C++ modification */
  205. %type <ttype> init initlist maybeasm
  206. %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
  207. %type <ttype> maybe_attribute attributes attribute attribute_list attrib
  208. %type <ttype> any_word
  209.  
  210. %type <ttype> compstmt implicitly_scoped_stmt
  211.  
  212. %type <ttype> declarator notype_declarator after_type_declarator
  213. %type <ttype> direct_notype_declarator direct_after_type_declarator
  214.  
  215. %type <ttype> structsp opt.component_decl_list component_decl_list
  216. %type <ttype> component_decl components component_declarator
  217. %type <ttype> notype_components notype_component_declarator
  218. %type <ttype> after_type_component_declarator after_type_component_declarator0
  219. %type <ttype> notype_component_declarator0 component_decl_1
  220. %type <ttype> enumlist enumerator
  221. %type <ttype> type_id absdcl type_quals
  222. %type <ttype> direct_abstract_declarator conversion_declarator
  223. %type <ttype> new_type_id new_declarator direct_new_declarator
  224. %type <ttype> xexpr parmlist parms parm bad_parm full_parm
  225. %type <ttype> identifiers_or_typenames
  226. %type <ttype> fcast_or_absdcl regcast_or_absdcl sub_cast_expr
  227. %type <ttype> expr_or_declarator complex_notype_declarator
  228. %type <ttype> notype_unqualified_id unqualified_id qualified_id
  229. %type <ttype> overqualified_id notype_qualified_id
  230. %type <ttype> complex_direct_notype_declarator functional_cast
  231. %type <ttype> named_parm complex_parmlist typed_declspecs1 parms_comma
  232.  
  233. /* C++ extensions */
  234. %token <ttype> TYPENAME_ELLIPSIS PTYPENAME
  235. %token <ttype> PRE_PARSED_FUNCTION_DECL EXTERN_LANG_STRING ALL
  236. %token <ttype> PRE_PARSED_CLASS_DECL
  237. %type <ttype> fn.def1 /* Not really! */
  238. %type <ttype> fn.def2 return_id
  239. %type <ttype> named_class_head named_class_head_sans_basetype
  240. %type <ttype> unnamed_class_head
  241. %type <ttype> class_head base_class_list
  242. %type <itype> base_class_access_list
  243. %type <ttype> base_class maybe_base_class_list base_class.1
  244. %type <ttype> maybe_raises ansi_raise_identifier ansi_raise_identifiers
  245. %type <ttype> component_declarator0
  246. %type <ttype> forhead.1 operator_name
  247. %type <ttype> object aggr
  248. %type <itype> new delete
  249. /* %type <ttype> primary_no_id */
  250. %type <ttype> nonmomentary_expr
  251. %type <itype> forhead.2 initdcl0 notype_initdcl0 member_init_list
  252. %type <ttype> template_header template_parm_list template_parm
  253. %type <ttype> template_type_parm
  254. %type <ttype> template_type template_arg_list template_arg
  255. %type <ttype> template_instantiation template_type_name tmpl.2
  256. %type <ttype> template_instantiate_once template_instantiate_some
  257. %type <itype> fn_tmpl_end
  258. /* %type <itype> try_for_typename */
  259. %type <ttype> condition xcond paren_cond_or_null
  260. %type <ttype> type_name nested_name_specifier nested_type ptr_to_mem
  261. %type <ttype> qualified_type_name complete_type_name notype_identifier
  262. %type <ttype> complex_type_name nested_name_specifier_1
  263. %type <itype> nomods_initdecls nomods_initdcl0
  264. %type <ttype> new_initializer new_placement specialization type_specifier_seq
  265.  
  266. /* in order to recognize aggr tags as defining and thus shadowing. */
  267. %token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN
  268. %type <ttype> named_class_head_sans_basetype_defn 
  269. %type <ttype> identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN
  270.  
  271. %type <strtype> .pushlevel
  272.  
  273. /* spew.c depends on this being the last token.  Define
  274.    any new tokens before this one!  */
  275. %token END_OF_SAVED_INPUT
  276.  
  277. %{
  278. /* List of types and structure classes of the current declaration.  */
  279. static tree current_declspecs;
  280.  
  281. /* When defining an aggregate, this is the most recent one being defined.  */
  282. static tree current_aggr;
  283.  
  284. /* Tell yyparse how to print a token's value, if yydebug is set.  */
  285.  
  286. #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
  287. extern void yyprint ();
  288. extern tree combine_strings        PROTO((tree));
  289. %}
  290.  
  291. %%
  292. program: /* empty */
  293.     | extdefs
  294.         {
  295.           /* In case there were missing closebraces,
  296.              get us back to the global binding level.  */
  297.           while (! global_bindings_p ())
  298.             poplevel (0, 0, 0);
  299.           finish_file ();
  300.         }
  301.     ;
  302.  
  303. /* the reason for the strange actions in this rule
  304.  is so that notype_initdecls when reached via datadef
  305.  can find a valid list of type and sc specs in $0. */
  306.  
  307. extdefs:
  308.       { $<ttype>$ = NULL_TREE; } lang_extdef
  309.         { $<ttype>$ = NULL_TREE; }
  310.     | extdefs lang_extdef
  311.         { $<ttype>$ = NULL_TREE; }
  312.     ;
  313.  
  314. .hush_warning:
  315.         { have_extern_spec = 1;
  316.           used_extern_spec = 0;
  317.           $<ttype>$ = NULL_TREE; }
  318.     ;
  319. .warning_ok:
  320.         { have_extern_spec = 0; }
  321.     ;
  322.  
  323. asm_keyword:
  324.       ASM_KEYWORD
  325.     | GCC_ASM_KEYWORD
  326.     ;
  327.  
  328. lang_extdef:
  329.       { if (pending_lang_change) do_pending_lang_change(); }
  330.       extdef
  331.       { if (! global_bindings_p () && ! pseudo_global_level_p())
  332.           pop_everything (); }
  333.     ;
  334.  
  335. extdef:
  336.       fndef
  337.         { if (pending_inlines) do_pending_inlines (); }
  338.     | datadef
  339.         { if (pending_inlines) do_pending_inlines (); }
  340.     | template_def
  341.         { if (pending_inlines) do_pending_inlines (); }
  342.     | overloaddef
  343.     | asm_keyword '(' string ')' ';'
  344.         { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
  345.           assemble_asm ($3); }
  346.     | extern_lang_string '{' extdefs '}'
  347.         { pop_lang_context (); }
  348.     | extern_lang_string '{' '}'
  349.         { pop_lang_context (); }
  350.     | extern_lang_string .hush_warning fndef .warning_ok
  351.         { if (pending_inlines) do_pending_inlines ();
  352.           pop_lang_context (); }
  353.     | extern_lang_string .hush_warning datadef .warning_ok
  354.         { if (pending_inlines) do_pending_inlines ();
  355.           pop_lang_context (); }
  356.     ;
  357.  
  358. extern_lang_string:
  359.       EXTERN_LANG_STRING
  360.         { push_lang_context ($1); }
  361.     ;
  362.  
  363. template_header:
  364.       TEMPLATE '<'
  365.         { begin_template_parm_list (); }
  366.       template_parm_list '>'
  367.         { $$ = end_template_parm_list ($4); }
  368.     ;
  369.  
  370. template_parm_list:
  371.       template_parm
  372.         { $$ = process_template_parm (NULL_TREE, $1); }
  373.     | template_parm_list ',' template_parm
  374.         { $$ = process_template_parm ($1, $3); }
  375.     ;
  376.  
  377. template_type_parm:
  378.       aggr
  379.         { 
  380.           $$ = build_tree_list ($1, NULL_TREE);
  381.          ttpa:
  382.           if (TREE_PURPOSE ($$) == signature_type_node)
  383.             sorry ("signature as template type parameter");
  384.           else if (TREE_PURPOSE ($$) != class_type_node)
  385.             pedwarn ("template type parameters must use the keyword `class'");
  386.         }
  387.     | aggr identifier
  388.         { $$ = build_tree_list ($1, $2); goto ttpa; }
  389.     ;
  390.  
  391. template_parm:
  392.     /* The following rules introduce a new reduce/reduce
  393.        conflict on the ',' and '>' input tokens: they are valid
  394.        prefixes for a `structsp', which means they could match a
  395.        nameless parameter.  See 14.6, paragraph 3.
  396.        By putting them before the `parm' rule, we get
  397.        their match before considering them nameless parameter
  398.        declarations.  */
  399.       template_type_parm
  400.         { $$ = build_tree_list (NULL_TREE, $$); }
  401.     | template_type_parm '=' typespec
  402.         { $$ = build_tree_list ($3, $$); }
  403.     | full_parm
  404.     ;
  405.  
  406. overloaddef:
  407.       OVERLOAD ov_identifiers ';'
  408.         { warning ("use of `overload' is an anachronism"); }
  409.     ;
  410.  
  411. ov_identifiers: IDENTIFIER
  412.         { declare_overloaded ($1); }
  413.     | ov_identifiers ',' IDENTIFIER
  414.         { declare_overloaded ($3); }
  415.     ;
  416.       
  417. template_def:
  418.     /* Class template declarations go here; they aren't normal class
  419.        declarations, because we can't process the bodies yet.  */
  420.       template_header named_class_head_sans_basetype '{'
  421.         { yychar = '{'; goto template1; }
  422.      ';'
  423.     | template_header named_class_head_sans_basetype_defn '{'
  424.         { yychar = '{'; goto template1; }
  425.      ';'
  426.     | template_header named_class_head_sans_basetype ':'
  427.         { yychar = ':'; goto template1; }
  428.      ';'
  429.     | template_header named_class_head_sans_basetype_defn ':'
  430.         {
  431.           yychar = ':';
  432.         template1:
  433.           if (current_aggr == exception_type_node)
  434.             error ("template type must define an aggregate or union");
  435.           else if (current_aggr == signature_type_node)
  436.             sorry ("template type defining a signature");
  437.           /* Maybe pedantic warning for union?
  438.              How about an enum? :-)  */
  439.           end_template_decl ($1, $2, current_aggr, 1);
  440.           reinit_parse_for_template (yychar, $1, $2);
  441.           yychar = YYEMPTY;
  442.         }
  443.       ';'
  444.     | template_header named_class_head_sans_basetype ';'
  445.         {
  446.           end_template_decl ($1, $2, current_aggr, 0);
  447.           /* declare $2 as template name with $1 parm list */
  448.         }
  449.     | template_header named_class_head_sans_basetype_defn ';'
  450.         {
  451.           end_template_decl ($1, $2, current_aggr, 0);
  452.           /* declare $2 as template name with $1 parm list */
  453.         }
  454.     | template_header /* notype_initdcl0 ';' */
  455.       notype_declarator maybe_raises maybeasm maybe_attribute
  456.       fn_tmpl_end
  457.         {
  458.           tree d;
  459.           int momentary;
  460.           int def = ($6 != ';');
  461.           momentary = suspend_momentary ();
  462.           d = start_decl ($<ttype>2, /*current_declspecs*/NULL_TREE, 0,
  463.                   $3);
  464.           cplus_decl_attributes (d, $5);
  465.           finish_decl (d, NULL_TREE, $4, 0);
  466.           end_template_decl ($1, d, 0, def);
  467.           if (def)
  468.             reinit_parse_for_template ((int) $6, $1, d);
  469.           resume_momentary (momentary);
  470.         }
  471.     | template_header typed_declspecs /*initdcl0*/
  472.       declarator maybe_raises maybeasm maybe_attribute
  473.       fn_tmpl_end
  474.         {
  475.           tree d;
  476.           int momentary;
  477.           int def = ($7 != ';');
  478.  
  479.           current_declspecs = $2;
  480.           momentary = suspend_momentary ();
  481.           d = start_decl ($<ttype>3, current_declspecs,
  482.                   0, $<ttype>4);
  483.           cplus_decl_attributes (d, $6);
  484.           finish_decl (d, NULL_TREE, $5, 0);
  485.           end_template_decl ($1, d, 0, def);
  486.           if (def)
  487.             {
  488.               reinit_parse_for_template ((int) $7, $1, d);
  489.               yychar = YYEMPTY;
  490.             }
  491.           note_list_got_semicolon ($<ttype>2);
  492.           resume_momentary (momentary);
  493.         }
  494.     | template_header declmods notype_declarator fn_tmpl_end
  495.         {
  496.           int def = ($4 != ';');
  497.           tree d = start_decl ($<ttype>3, $<ttype>2, 0, NULL_TREE);
  498.           finish_decl (d, NULL_TREE, NULL_TREE, 0);
  499.           end_template_decl ($1, d, 0, def);
  500.           if (def)
  501.             reinit_parse_for_template ((int) $4, $1, d);
  502.         }
  503.     /* Try to recover from syntax errors in templates.  */
  504.     | template_header error '}'    { end_template_decl ($1, 0, 0, 0); }
  505.     | template_header error ';'    { end_template_decl ($1, 0, 0, 0); }
  506.     ;
  507.  
  508. fn_tmpl_end: '{'        { $$ = '{'; }
  509.     | ':'            { $$ = ':'; }
  510.     | ';'            { $$ = ';'; }
  511.     | '='            { $$ = '='; }
  512.     | RETURN        { $$ = RETURN; }
  513.     ;
  514.  
  515. datadef:
  516.       nomods_initdecls ';'
  517.         {}
  518.     | declmods notype_initdecls ';'
  519.         {}
  520.     /* Normal case to make fast: "const i;".  */
  521.     | declmods notype_declarator ';'
  522.         { tree d;
  523.           d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
  524.           finish_decl (d, NULL_TREE, NULL_TREE, 0);
  525.         }
  526.     | typed_declspecs initdecls ';'
  527.         {
  528.           note_list_got_semicolon ($<ttype>$);
  529.         }
  530.     /* Normal case: make this fast.  */
  531.     | typed_declspecs declarator ';'
  532.         { tree d;
  533.           d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
  534.           finish_decl (d, NULL_TREE, NULL_TREE, 0);
  535.           note_list_got_semicolon ($<ttype>$);
  536.         }
  537.         | declmods ';'
  538.       { pedwarn ("empty declaration"); }
  539.     | explicit_instantiation ';'
  540.     | typed_declspecs ';'
  541.       {
  542.         tree t = $<ttype>$;
  543.         shadow_tag (t);
  544.         if (TREE_CODE (t) == TREE_LIST
  545.         && TREE_PURPOSE (t) == NULL_TREE)
  546.           {
  547.         t = TREE_VALUE (t);
  548.         if (IS_AGGR_TYPE (t)
  549.             && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (t)))
  550.           {
  551.             if (CLASSTYPE_USE_TEMPLATE (t) == 0)
  552.               SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t);
  553.             else if (CLASSTYPE_TEMPLATE_INSTANTIATION (t))
  554.               error ("override declaration for already-expanded template");
  555.           }
  556.           }
  557.         note_list_got_semicolon ($<ttype>$);
  558.       }
  559.     | error ';'
  560.     | error '}'
  561.     | ';'
  562.     ;
  563.  
  564. fndef:
  565.       fn.def1 base_init compstmt_or_error
  566.         {
  567.           finish_function (lineno, 1);
  568.           /* finish_function performs these three statements:
  569.  
  570.              expand_end_bindings (getdecls (), 1, 0);
  571.              poplevel (1, 1, 0);
  572.  
  573.              expand_end_bindings (0, 0, 0);
  574.              poplevel (0, 0, 1);
  575.              */
  576.           if ($<ttype>$) process_next_inline ($<ttype>$);
  577.         }
  578.     | fn.def1 return_init base_init compstmt_or_error
  579.         {
  580.           finish_function (lineno, 1);
  581.           /* finish_function performs these three statements:
  582.  
  583.              expand_end_bindings (getdecls (), 1, 0);
  584.              poplevel (1, 1, 0);
  585.  
  586.              expand_end_bindings (0, 0, 0);
  587.              poplevel (0, 0, 1);
  588.              */
  589.           if ($<ttype>$) process_next_inline ($<ttype>$);
  590.         }
  591.     | fn.def1 nodecls compstmt_or_error
  592.         { finish_function (lineno, 0);
  593.           if ($<ttype>$) process_next_inline ($<ttype>$); }
  594.     | fn.def1 return_init ';' nodecls compstmt_or_error
  595.         { finish_function (lineno, 0);
  596.           if ($<ttype>$) process_next_inline ($<ttype>$); }
  597.     | fn.def1 return_init nodecls compstmt_or_error
  598.         { finish_function (lineno, 0);
  599.           if ($<ttype>$) process_next_inline ($<ttype>$); }
  600.     | typed_declspecs declarator error
  601.         {}
  602.     | declmods notype_declarator error
  603.         {}
  604.     | notype_declarator error
  605.         {}
  606.     ;
  607.  
  608. fn.def1:
  609.       typed_declspecs declarator maybe_raises
  610.         { if (! start_function ($$, $2, $3, 0))
  611.             YYERROR1;
  612.           reinit_parse_for_function ();
  613.           $$ = NULL_TREE; }
  614.     | declmods notype_declarator maybe_raises
  615.         { if (! start_function ($$, $2, $3, 0))
  616.             YYERROR1;
  617.           reinit_parse_for_function ();
  618.           $$ = NULL_TREE; }
  619.     | notype_declarator maybe_raises
  620.         { if (! start_function (NULL_TREE, $$, $2, 0))
  621.             YYERROR1;
  622.           reinit_parse_for_function ();
  623.           $$ = NULL_TREE; }
  624.     | PRE_PARSED_FUNCTION_DECL
  625.         { start_function (NULL_TREE, TREE_VALUE ($$), NULL_TREE, 1);
  626.           reinit_parse_for_function (); }
  627.     ;
  628.  
  629. /* more C++ complexity.  See component_decl for a comment on the
  630.    reduce/reduce conflict introduced by these rules.  */
  631. fn.def2:
  632.       typed_declspecs '(' parmlist ')' type_quals maybe_raises
  633.         {
  634.           $$ = build_parse_node (CALL_EXPR, TREE_VALUE ($1), $3, $5);
  635.           $$ = start_method (TREE_CHAIN ($1), $$, $6);
  636.          rest_of_mdef:
  637.           if (! $$)
  638.             YYERROR1;
  639.           if (yychar == YYEMPTY)
  640.             yychar = YYLEX;
  641.           reinit_parse_for_method (yychar, $$); }
  642.     | typed_declspecs LEFT_RIGHT type_quals maybe_raises
  643.         {
  644.           $$ = build_parse_node (CALL_EXPR, TREE_VALUE ($1),
  645.                      empty_parms (), $3);
  646.           $$ = start_method (TREE_CHAIN ($1), $$, $4);
  647.           goto rest_of_mdef;
  648.         }
  649.     | typed_declspecs declarator maybe_raises
  650.         { $$ = start_method ($$, $2, $3); goto rest_of_mdef; }
  651.     | declmods notype_declarator maybe_raises
  652.         { $$ = start_method ($$, $2, $3); goto rest_of_mdef; }
  653.     | notype_declarator maybe_raises
  654.         { $$ = start_method (NULL_TREE, $$, $2); goto rest_of_mdef; }
  655.     ;
  656.  
  657. return_id: RETURN IDENTIFIER
  658.         {
  659.           if (! current_function_parms_stored)
  660.             store_parm_decls ();
  661.           $$ = $2;
  662.         }
  663.     ;
  664.  
  665. return_init: return_id
  666.         { store_return_init ($<ttype>$, NULL_TREE); }
  667.     | return_id '=' init
  668.         { store_return_init ($<ttype>$, $3); }
  669.     | return_id '(' nonnull_exprlist ')'
  670.         { store_return_init ($<ttype>$, $3); }
  671.     | return_id LEFT_RIGHT
  672.         { store_return_init ($<ttype>$, NULL_TREE); }
  673.     ;
  674.  
  675. base_init:
  676.       ':' .set_base_init member_init_list
  677.         {
  678.           if ($3 == 0)
  679.             error ("no base initializers given following ':'");
  680.           setup_vtbl_ptr ();
  681.           /* Always keep the BLOCK node associated with the outermost
  682.              pair of curley braces of a function.  These are needed
  683.              for correct operation of dwarfout.c.  */
  684.           keep_next_level ();
  685.         }
  686.     ;
  687.  
  688. .set_base_init:
  689.     /* empty */
  690.         {
  691.           if (! current_function_parms_stored)
  692.             store_parm_decls ();
  693.  
  694.           /* Flag that we are processing base and member initializers.  */
  695.           current_vtable_decl = error_mark_node;
  696.  
  697.           if (DECL_CONSTRUCTOR_P (current_function_decl))
  698.             {
  699.               /* Make a contour for the initializer list.  */
  700.               pushlevel (0);
  701.               clear_last_expr ();
  702.               expand_start_bindings (0);
  703.             }
  704.           else if (current_class_type == NULL_TREE)
  705.             error ("base initializers not allowed for non-member functions");
  706.           else if (! DECL_CONSTRUCTOR_P (current_function_decl))
  707.             error ("only constructors take base initializers");
  708.         }
  709.     ;
  710.  
  711. member_init_list:
  712.       /* empty */
  713.         { $$ = 0; }
  714.     | member_init
  715.         { $$ = 1; }
  716.     | member_init_list ',' member_init
  717.     | member_init_list error
  718.     ;
  719.  
  720. member_init: '(' nonnull_exprlist ')'
  721.         {
  722.           if (current_class_name && !flag_traditional)
  723.             pedwarn ("anachronistic old style base class initializer");
  724.           expand_member_init (C_C_D, NULL_TREE, $2);
  725.         }
  726.     | LEFT_RIGHT
  727.         {
  728.           if (current_class_name && !flag_traditional)
  729.             pedwarn ("anachronistic old style base class initializer");
  730.           expand_member_init (C_C_D, NULL_TREE, void_type_node);
  731.         }
  732.     | notype_identifier '(' nonnull_exprlist ')'
  733.         { expand_member_init (C_C_D, $<ttype>$, $3); }
  734.     | notype_identifier LEFT_RIGHT
  735.         { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
  736.     | complete_type_name '(' nonnull_exprlist ')'
  737.         { expand_member_init (C_C_D, $<ttype>$, $3); }
  738.     | complete_type_name LEFT_RIGHT
  739.         { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
  740.     /* GNU extension */
  741.     | notype_qualified_id '(' nonnull_exprlist ')'
  742.         {
  743.           do_member_init (OP0 ($1), OP1 ($1), $3);
  744.         }
  745.     | notype_qualified_id LEFT_RIGHT
  746.         {
  747.           do_member_init (OP0 ($1), OP1 ($1), void_type_node);
  748.         }
  749.     ;
  750.  
  751. identifier:
  752.       IDENTIFIER
  753.     | TYPENAME
  754.     | PTYPENAME
  755.     ;
  756.  
  757. notype_identifier:
  758.       IDENTIFIER
  759.     | PTYPENAME %prec EMPTY
  760.     ;
  761.  
  762. identifier_defn:
  763.       IDENTIFIER_DEFN
  764.     | TYPENAME_DEFN
  765.     | PTYPENAME_DEFN
  766.     ;
  767.  
  768. explicit_instantiation:
  769.       TEMPLATE specialization template_instantiation
  770.         { do_type_instantiation ($3 ? $3 : $2, NULL_TREE); }
  771.     | TEMPLATE typed_declspecs declarator
  772.         { do_function_instantiation ($2, $3, NULL_TREE); }
  773.     | SCSPEC TEMPLATE specialization template_instantiation
  774.         { do_type_instantiation ($4 ? $4 : $3, $1); }
  775.     | SCSPEC TEMPLATE typed_declspecs declarator
  776.         { do_function_instantiation ($3, $4, $1); }
  777.     ;
  778.  
  779. template_type:
  780.       template_type_name tmpl.2 template_instantiation
  781.         { if ($3) $$ = $3; }
  782.     ;
  783.  
  784. template_type_name:
  785.       PTYPENAME '<' template_arg_list '>'
  786.         { $$ = lookup_template_class ($$, $3, NULL_TREE); }
  787.     | PTYPENAME '<' '>'
  788.         { $$ = lookup_template_class ($$, NULL_TREE, NULL_TREE); }
  789.     | TYPENAME  '<' template_arg_list '>'
  790.         { $$ = lookup_template_class ($$, $3, NULL_TREE); }
  791.     ;
  792.  
  793. tmpl.2: 
  794.       /* empty */ %prec EMPTY
  795.         { $$ = instantiate_class_template ($<ttype>0, 1); }
  796.     ;
  797.  
  798. template_arg_list:
  799.       template_arg
  800.         { $$ = build_tree_list (NULL_TREE, $$); }
  801.     | template_arg_list ',' template_arg
  802.         { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
  803.     ;
  804.  
  805. template_arg:
  806.       type_id
  807.         { $$ = groktypename ($$); }
  808.     | expr_no_commas  %prec UNARY
  809.     ;
  810.  
  811. template_instantiate_once:
  812.       PRE_PARSED_CLASS_DECL maybe_base_class_list
  813.         {
  814.           tree t, decl, tmpl;
  815.  
  816.           tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE ($1));
  817.           t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, $1, $2, 0);
  818.           set_current_level_tags_transparency (1);
  819.           my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
  820.                       || TREE_CODE (t) == UNION_TYPE, 257);
  821.           $<ttype>$ = t;
  822.  
  823.           /* Now, put a copy of the decl in global scope, to avoid
  824.              recursive expansion.  */
  825.           decl = IDENTIFIER_LOCAL_VALUE ($1);
  826.           if (!decl)
  827.             decl = IDENTIFIER_CLASS_VALUE ($1);
  828.           /* Now, put a copy of the decl in global scope, to avoid
  829.              recursive expansion.  */
  830.                   if (decl)
  831.                     {
  832.               /* Need to copy it to clear the chain pointer,
  833.              and need to get it into permanent storage.  */
  834.                       my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 258);
  835.               push_obstacks (&permanent_obstack, &permanent_obstack);
  836.                       decl = copy_node (decl);
  837.               if (DECL_LANG_SPECIFIC (decl))
  838.             copy_lang_decl (decl);
  839.               pop_obstacks ();
  840.               pushdecl_top_level (decl);
  841.             }
  842.           /* Kludge; see instantiate_class_template.  */
  843.           TYPE_BEING_DEFINED (t) = 0;
  844.         }
  845.       left_curly opt.component_decl_list '}'
  846.         {
  847.           tree t = finish_struct ($<ttype>3, $5, 0);
  848.  
  849.           pop_obstacks ();
  850.           end_template_instantiation ($1);
  851.  
  852.                   /* Now go after the methods & class data.  */
  853.                   instantiate_member_templates ($1);
  854.  
  855.           pop_tinst_level();
  856.  
  857.           CLASSTYPE_GOT_SEMICOLON (t) = 1;
  858.         }
  859.     ;
  860.  
  861. template_instantiation:
  862.           /* empty */
  863.                 { $$ = NULL_TREE; }
  864.         | template_instantiate_once
  865.                 { $$ = $1; }
  866.         ;
  867.  
  868. template_instantiate_some:
  869.           /* empty */
  870.                 { $$ = NULL_TREE; /* never used from here... */}
  871.         | template_instantiate_once template_instantiate_some
  872.                 { $$ = $1; /*???*/ }
  873.         ;
  874.  
  875. unop:     '-'
  876.         { $$ = NEGATE_EXPR; }
  877.     | '+'
  878.         { $$ = CONVERT_EXPR; }
  879.     | PLUSPLUS
  880.         { $$ = PREINCREMENT_EXPR; }
  881.     | MINUSMINUS
  882.         { $$ = PREDECREMENT_EXPR; }
  883.     | '!'
  884.         { $$ = TRUTH_NOT_EXPR; }
  885.     ;
  886.  
  887. expr:      nontrivial_exprlist
  888.         { $$ = build_x_compound_expr ($$); }
  889.     | expr_no_commas
  890.     ;
  891.  
  892. paren_expr_or_null:
  893.     LEFT_RIGHT
  894.         { error ("ANSI C++ forbids an empty condition for `%s'",
  895.              cond_stmt_keyword);
  896.           $$ = integer_zero_node; }
  897.     | '(' expr ')'
  898.         { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, 
  899.                    bool_truthvalue_conversion ($2)); }
  900.     ;
  901.  
  902. paren_cond_or_null:
  903.     LEFT_RIGHT
  904.         { error ("ANSI C++ forbids an empty condition for `%s'",
  905.              cond_stmt_keyword);
  906.           $$ = integer_zero_node; }
  907.     | '(' condition ')'
  908.         { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, 
  909.                    bool_truthvalue_conversion ($2)); }
  910.     ;
  911.  
  912. xcond:
  913.     /* empty */
  914.         { $$ = NULL_TREE; }
  915.     | condition
  916.         { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, 
  917.                    bool_truthvalue_conversion ($$)); }
  918.     | error
  919.         { $$ = NULL_TREE; }
  920.     ;
  921.  
  922. condition:
  923.     type_specifier_seq declarator maybe_raises maybeasm maybe_attribute '='
  924.         { {
  925.           tree d;
  926.           for (d = getdecls (); d; d = TREE_CHAIN (d))
  927.             if (TREE_CODE (d) == TYPE_DECL) {
  928.               tree s = TREE_TYPE (d);
  929.               if (TREE_CODE (s) == RECORD_TYPE)
  930.             cp_error ("definition of class `%T' in condition", s);
  931.               else if (TREE_CODE (s) == ENUMERAL_TYPE)
  932.             cp_error ("definition of enum `%T' in condition", s);
  933.             }
  934.           }
  935.           current_declspecs = $1;
  936.           $<itype>6 = suspend_momentary ();
  937.           $<ttype>$ = start_decl ($<ttype>2, current_declspecs, 1, $3);
  938.           cplus_decl_attributes ($<ttype>$, $5);
  939.         }
  940.     init
  941.         { 
  942.           finish_decl ($<ttype>7, $8, $5, 0);
  943.           resume_momentary ($<itype>6);
  944.           $$ = $<ttype>7; 
  945.           if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE)
  946.             cp_error ("definition of array `%#D' in condition", $$); 
  947.         }
  948.     | expr
  949.     ;
  950.  
  951. already_scoped_stmt:
  952.       '{' '}'
  953.         { finish_stmt (); }
  954.     | '{' maybe_label_decls stmts '}'
  955.         { finish_stmt (); }
  956.     | '{' maybe_label_decls error '}'
  957.         { finish_stmt (); }
  958.     | simple_stmt
  959.     ;
  960.  
  961.  
  962. nontrivial_exprlist:
  963.       expr_no_commas ',' expr_no_commas
  964.         { $$ = tree_cons (NULL_TREE, $$, 
  965.                           build_tree_list (NULL_TREE, $3)); }
  966.     | expr_no_commas ',' error
  967.         { $$ = tree_cons (NULL_TREE, $$, 
  968.                           build_tree_list (NULL_TREE, error_mark_node)); }
  969.     | nontrivial_exprlist ',' expr_no_commas
  970.         { chainon ($$, build_tree_list (NULL_TREE, $3)); }
  971.     | nontrivial_exprlist ',' error
  972.         { chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); }
  973.     ;
  974.  
  975. nonnull_exprlist:
  976.       expr_no_commas
  977.         { $$ = build_tree_list (NULL_TREE, $$); }
  978.     | nontrivial_exprlist
  979.     ;
  980.  
  981. unary_expr:
  982.       primary %prec UNARY
  983.         {
  984. #if 0
  985.           if (TREE_CODE ($$) == TYPE_EXPR)
  986.             $$ = build_component_type_expr (C_C_D, $$, NULL_TREE, 1);
  987. #endif
  988.         }
  989.     /* __extension__ turns off -pedantic for following primary.  */
  990.     | EXTENSION
  991.         { $<itype>1 = pedantic;
  992.           pedantic = 0; }
  993.       cast_expr      %prec UNARY
  994.         { $$ = $3;
  995.           pedantic = $<itype>1; }
  996.     | '*' cast_expr   %prec UNARY
  997.         { $$ = build_x_indirect_ref ($2, "unary *"); }
  998.     | '&' cast_expr   %prec UNARY
  999.         { $$ = build_x_unary_op (ADDR_EXPR, $2); }
  1000.     | '~' cast_expr
  1001.         { $$ = build_x_unary_op (BIT_NOT_EXPR, $2); }
  1002.     | unop cast_expr  %prec UNARY
  1003.         { $$ = build_x_unary_op ($1, $2);
  1004.           if ($1 == NEGATE_EXPR && TREE_CODE ($2) == INTEGER_CST)
  1005.             TREE_NEGATED_INT ($$) = 1;
  1006.           overflow_warning ($$);
  1007.         }
  1008.     /* Refer to the address of a label as a pointer.  */
  1009.     | ANDAND identifier
  1010.         { tree label = lookup_label ($2);
  1011.           if (label == NULL_TREE)
  1012.             $$ = null_pointer_node;
  1013.           else
  1014.             {
  1015.               TREE_USED (label) = 1;
  1016.               $$ = build1 (ADDR_EXPR, ptr_type_node, label);
  1017.               TREE_CONSTANT ($$) = 1;
  1018.             }
  1019.         }
  1020.     | SIZEOF unary_expr  %prec UNARY
  1021.         { if (TREE_CODE ($2) == COMPONENT_REF
  1022.               && DECL_BIT_FIELD (TREE_OPERAND ($2, 1)))
  1023.             error ("sizeof applied to a bit-field");
  1024.           /* ANSI says arrays and functions are converted inside comma.
  1025.              But we can't really convert them in build_compound_expr
  1026.              because that would break commas in lvalues.
  1027.              So do the conversion here if operand was a comma.  */
  1028.           if (TREE_CODE ($2) == COMPOUND_EXPR
  1029.               && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE
  1030.               || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE))
  1031.             $2 = default_conversion ($2);
  1032.           else if (TREE_CODE ($2) == TREE_LIST)
  1033.                 {
  1034.               tree t = TREE_VALUE ($2);
  1035.               if (t != NULL_TREE
  1036.               && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
  1037.             pedwarn ("ANSI C++ forbids using sizeof() on a function");
  1038.             }
  1039.           $$ = c_sizeof (TREE_TYPE ($2)); }
  1040.     | SIZEOF '(' type_id ')'  %prec HYPERUNARY
  1041.         { $$ = c_sizeof (groktypename ($3)); }
  1042.     | ALIGNOF unary_expr  %prec UNARY
  1043.         { $$ = grok_alignof ($2); }
  1044.     | ALIGNOF '(' type_id ')'  %prec HYPERUNARY
  1045.         { $$ = c_alignof (groktypename ($3)); }
  1046.  
  1047.     /* The %prec EMPTY's here are required by the = init initializer
  1048.        syntax extension; see below.  */
  1049.     | new new_type_id %prec EMPTY
  1050.         { $$ = build_new (NULL_TREE, $2, NULL_TREE, $1); }
  1051.     | new new_type_id new_initializer
  1052.         { $$ = build_new (NULL_TREE, $2, $3, $1); }
  1053.     | new new_placement new_type_id %prec EMPTY
  1054.         { $$ = build_new ($2, $3, NULL_TREE, $1); }
  1055.     | new new_placement new_type_id new_initializer
  1056.         { $$ = build_new ($2, $3, $4, $1); }
  1057.     | new '(' type_id ')' %prec EMPTY
  1058.         { $$ = build_new (NULL_TREE, groktypename($3),
  1059.                   NULL_TREE, $1); }
  1060.     | new '(' type_id ')' new_initializer
  1061.         { $$ = build_new (NULL_TREE, groktypename($3), $5, $1); }
  1062.     | new new_placement '(' type_id ')' %prec EMPTY
  1063.         { $$ = build_new ($2, groktypename($4), NULL_TREE, $1); }
  1064.     | new new_placement '(' type_id ')' new_initializer
  1065.         { $$ = build_new ($2, groktypename($4), $6, $1); }
  1066.  
  1067.     | delete cast_expr  %prec UNARY
  1068.         { $$ = delete_sanity ($2, NULL_TREE, 0, $1); }
  1069.     | delete '[' ']' cast_expr  %prec UNARY
  1070.         { $$ = delete_sanity ($4, NULL_TREE, 1, $1);
  1071.           if (yychar == YYEMPTY)
  1072.             yychar = YYLEX; }
  1073.     | delete '[' expr ']' cast_expr %prec UNARY
  1074.         { $$ = delete_sanity ($5, $3, 2, $1);
  1075.           if (yychar == YYEMPTY)
  1076.             yychar = YYLEX; }
  1077.     ;
  1078.  
  1079. new_placement:
  1080.       '(' nonnull_exprlist ')'
  1081.         { $$ = $2; }
  1082.     | '{' nonnull_exprlist '}'
  1083.         {
  1084.           $$ = $2; 
  1085.           pedwarn ("old style placement syntax, use () instead");
  1086.         }
  1087.     ;
  1088.  
  1089. new_initializer:
  1090.       '(' nonnull_exprlist ')'
  1091.         { $$ = $2; }
  1092.     | LEFT_RIGHT
  1093.         { $$ = NULL_TREE; }
  1094.     | '(' typespec ')'
  1095.         {
  1096.           cp_error ("`%T' is not a valid expression", $2);
  1097.           $$ = error_mark_node;
  1098.         }
  1099.     /* GNU extension so people can use initializer lists.  Note that
  1100.        this alters the meaning of `new int = 1', which was previously
  1101.        syntactically valid but semantically invalid.  */
  1102.     | '=' init
  1103.         {
  1104.           if (flag_ansi)
  1105.             pedwarn ("ANSI C++ forbids initialization of new expression with `='");
  1106.           $$ = $2;
  1107.         }
  1108.     ;
  1109.  
  1110. /* This is necessary to postpone reduction of `int ((int)(int)(int))'.  */
  1111. regcast_or_absdcl:
  1112.       '(' type_id ')' %prec EMPTY
  1113.         { $2 = tree_cons (NULL_TREE, $2, void_list_node);
  1114.           TREE_PARMLIST ($2) = 1;
  1115.           $$ = build_parse_node (CALL_EXPR, NULL_TREE, $2, 
  1116.                      NULL_TREE); }
  1117.     | regcast_or_absdcl '(' type_id ')' %prec EMPTY
  1118.         { $3 = tree_cons (NULL_TREE, $3, void_list_node);
  1119.           TREE_PARMLIST ($3) = 1;
  1120.           $$ = build_parse_node (CALL_EXPR, $$, $3, NULL_TREE); }
  1121.     ;
  1122.  
  1123. cast_expr:
  1124.       sub_cast_expr
  1125.     | regcast_or_absdcl sub_cast_expr  %prec UNARY
  1126.         { $$ = reparse_absdcl_as_casts ($$, $2); }
  1127.     | regcast_or_absdcl '{' initlist maybecomma '}'  %prec UNARY
  1128.         { 
  1129.           tree init = build_nt (CONSTRUCTOR, NULL_TREE,
  1130.                     nreverse ($3)); 
  1131.           if (flag_ansi)
  1132.             pedwarn ("ANSI C++ forbids constructor-expressions");
  1133.           /* Indicate that this was a GNU C constructor expression.  */
  1134.           TREE_HAS_CONSTRUCTOR (init) = 1;
  1135.  
  1136.           $$ = reparse_absdcl_as_casts ($$, init);
  1137.         }
  1138.     ;
  1139.  
  1140. sub_cast_expr:
  1141.       unary_expr
  1142.     | HEADOF '(' expr ')'
  1143.         { $$ = build_headof ($3); }
  1144.     | CLASSOF '(' expr ')'
  1145.         { $$ = build_classof ($3); }
  1146.     | CLASSOF '(' TYPENAME ')'
  1147.         { if (is_aggr_typedef ($3, 1))
  1148.             {
  1149.               tree type = IDENTIFIER_TYPE_VALUE ($3);
  1150.               if (! IS_SIGNATURE(type))
  1151.             $$ = CLASSTYPE_DOSSIER (type);
  1152.               else
  1153.             {
  1154.               sorry ("signature name as argument of `classof'");
  1155.               $$ = error_mark_node;
  1156.             }
  1157.             }
  1158.           else
  1159.             $$ = error_mark_node;
  1160.         }
  1161.     ;
  1162.  
  1163. expr_no_commas:
  1164.       cast_expr
  1165.     /* Handle general members.  */
  1166.     | expr_no_commas POINTSAT_STAR expr_no_commas
  1167.         { $$ = build_x_binary_op (MEMBER_REF, $$, $3); }
  1168.     | expr_no_commas DOT_STAR expr_no_commas
  1169.         { $$ = build_m_component_ref ($$, $3); }
  1170.     | expr_no_commas '+' expr_no_commas
  1171.         { $$ = build_x_binary_op ($2, $$, $3); }
  1172.     | expr_no_commas '-' expr_no_commas
  1173.         { $$ = build_x_binary_op ($2, $$, $3); }
  1174.     | expr_no_commas '*' expr_no_commas
  1175.         { $$ = build_x_binary_op ($2, $$, $3); }
  1176.     | expr_no_commas '/' expr_no_commas
  1177.         { $$ = build_x_binary_op ($2, $$, $3); }
  1178.     | expr_no_commas '%' expr_no_commas
  1179.         { $$ = build_x_binary_op ($2, $$, $3); }
  1180.     | expr_no_commas LSHIFT expr_no_commas
  1181.         { $$ = build_x_binary_op ($2, $$, $3); }
  1182.     | expr_no_commas RSHIFT expr_no_commas
  1183.         { $$ = build_x_binary_op ($2, $$, $3); }
  1184.     | expr_no_commas ARITHCOMPARE expr_no_commas
  1185.         { $$ = build_x_binary_op ($2, $$, $3); }
  1186.     | expr_no_commas '<' expr_no_commas
  1187.         { $$ = build_x_binary_op (LT_EXPR, $$, $3); }
  1188.     | expr_no_commas '>' expr_no_commas
  1189.         { $$ = build_x_binary_op (GT_EXPR, $$, $3); }
  1190.     | expr_no_commas EQCOMPARE expr_no_commas
  1191.         { $$ = build_x_binary_op ($2, $$, $3); }
  1192.     | expr_no_commas MIN_MAX expr_no_commas
  1193.         { $$ = build_x_binary_op ($2, $$, $3); }
  1194.     | expr_no_commas '&' expr_no_commas
  1195.         { $$ = build_x_binary_op ($2, $$, $3); }
  1196.     | expr_no_commas '|' expr_no_commas
  1197.         { $$ = build_x_binary_op ($2, $$, $3); }
  1198.     | expr_no_commas '^' expr_no_commas
  1199.         { $$ = build_x_binary_op ($2, $$, $3); }
  1200.     | expr_no_commas ANDAND expr_no_commas
  1201.         { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); }
  1202.     | expr_no_commas OROR expr_no_commas
  1203.         { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); }
  1204.     | expr_no_commas '?' xexpr ':' expr_no_commas
  1205.         { $$ = build_x_conditional_expr ($$, $3, $5); }
  1206.     | expr_no_commas '=' expr_no_commas
  1207.         { $$ = build_modify_expr ($$, NOP_EXPR, $3); }
  1208.     | expr_no_commas ASSIGN expr_no_commas
  1209.         { register tree rval;
  1210.           if ((rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, $$, $3,
  1211.                          make_node ($2))))
  1212.             $$ = rval;
  1213.           else
  1214.             $$ = build_modify_expr ($$, $2, $3); }
  1215.     | THROW
  1216.         { $$ = build_throw (NULL_TREE); }
  1217.     | THROW expr_no_commas
  1218.         { $$ = build_throw ($2); }
  1219. /* These extensions are not defined.  The second arg to build_m_component_ref
  1220.    is old, build_m_component_ref now does an implicit
  1221.    build_indirect_ref (x, NULL_PTR) on the second argument.
  1222.     | object '&' expr_no_commas   %prec UNARY
  1223.         { $$ = build_m_component_ref ($$, build_x_unary_op (ADDR_EXPR, $3)); }
  1224.     | object unop expr_no_commas  %prec UNARY
  1225.         { $$ = build_m_component_ref ($$, build_x_unary_op ($2, $3)); }
  1226.     | object '(' type_id ')' expr_no_commas  %prec UNARY
  1227.         { tree type = groktypename ($3);
  1228.           $$ = build_m_component_ref ($$, build_c_cast (type, $5)); }
  1229.     | object primary_no_id  %prec UNARY
  1230.         { $$ = build_m_component_ref ($$, $2); }
  1231. */
  1232.     ;
  1233.  
  1234. notype_unqualified_id:
  1235.       '~' see_typename identifier
  1236.         { $$ = build_parse_node (BIT_NOT_EXPR, $3); }
  1237.     | operator_name
  1238.     | IDENTIFIER
  1239.     | PTYPENAME %prec EMPTY
  1240.     ;
  1241.  
  1242. unqualified_id:
  1243.       notype_unqualified_id
  1244.     | TYPENAME
  1245.     ;
  1246.  
  1247. expr_or_declarator:
  1248.       notype_unqualified_id
  1249.     | notype_qualified_id
  1250.     | '*' expr_or_declarator %prec UNARY
  1251.         { $$ = build_parse_node (INDIRECT_REF, $2); }
  1252.     | '&' expr_or_declarator %prec UNARY
  1253.         { $$ = build_parse_node (ADDR_EXPR, $2); }
  1254.     ;
  1255.  
  1256. direct_notype_declarator:
  1257.       complex_direct_notype_declarator
  1258.     | notype_unqualified_id
  1259.     | notype_qualified_id
  1260.         { push_nested_class (TREE_TYPE (OP0 ($$)), 3);
  1261.           TREE_COMPLEXITY ($$) = current_class_depth; }
  1262.     ;
  1263.  
  1264. primary:
  1265.       notype_unqualified_id
  1266.         {
  1267.           if (TREE_CODE ($$) == BIT_NOT_EXPR)
  1268.             $$ = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND ($$, 0));
  1269.           else if (IDENTIFIER_OPNAME_P ($$))
  1270.             {
  1271.               tree op = $$;
  1272.               $$ = lookup_name (op, 0);
  1273.               if ($$ == NULL_TREE)
  1274.             {
  1275.               if (op != ansi_opname[ERROR_MARK])
  1276.                 error ("operator %s not defined",
  1277.                    operator_name_string (op));
  1278.               $$ = error_mark_node;
  1279.             }
  1280.             }
  1281.           else
  1282.             $$ = do_identifier ($$);
  1283.         }        
  1284.     | CONSTANT
  1285.     | boolean.literal
  1286.     | string
  1287.         { $$ = combine_strings ($$); }
  1288.     | '(' expr ')'
  1289.         { $$ = $2; }
  1290.     | '(' error ')'
  1291.         { $$ = error_mark_node; }
  1292.     | '('
  1293.         { if (current_function_decl == 0)
  1294.             {
  1295.               error ("braced-group within expression allowed only inside a function");
  1296.               YYERROR;
  1297.             }
  1298.           keep_next_level ();
  1299.           $<ttype>$ = expand_start_stmt_expr (); }
  1300.       compstmt ')'
  1301.         { tree rtl_exp;
  1302.           if (flag_ansi)
  1303.             pedwarn ("ANSI C++ forbids braced-groups within expressions");
  1304.           rtl_exp = expand_end_stmt_expr ($<ttype>2);
  1305.           /* The statements have side effects, so the group does.  */
  1306.           TREE_SIDE_EFFECTS (rtl_exp) = 1;
  1307.  
  1308.           if (TREE_CODE ($3) == BLOCK)
  1309.             {
  1310.               /* Make a BIND_EXPR for the BLOCK already made.  */
  1311.               $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
  1312.                   NULL_TREE, rtl_exp, $3);
  1313.               /* Remove the block from the tree at this point.
  1314.              It gets put back at the proper place
  1315.              when the BIND_EXPR is expanded.  */
  1316.               delete_block ($3);
  1317.             }
  1318.           else
  1319.             $$ = $3;
  1320.         }
  1321.     | primary '(' nonnull_exprlist ')'
  1322.                 { /* [eichin:19911016.1902EST] */
  1323.                   $<ttype>$ = build_x_function_call ($1, $3, current_class_decl); 
  1324.                   /* here we instantiate_class_template as needed... */
  1325.                   do_pending_templates ();
  1326.                 } template_instantiate_some {
  1327.                   if (TREE_CODE ($<ttype>5) == CALL_EXPR
  1328.                       && TREE_TYPE ($<ttype>5) != void_type_node)
  1329.                 $$ = require_complete_type ($<ttype>5);
  1330.                   else
  1331.                     $$ = $<ttype>5;
  1332.                 }
  1333.     | primary LEFT_RIGHT
  1334.                 {
  1335.           $$ = build_x_function_call ($$, NULL_TREE, current_class_decl);
  1336.           if (TREE_CODE ($$) == CALL_EXPR
  1337.               && TREE_TYPE ($$) != void_type_node)
  1338.             $$ = require_complete_type ($$);
  1339.                 }
  1340.     | primary '[' expr ']'
  1341.         { $$ = grok_array_decl ($$, $3); }
  1342.     | primary PLUSPLUS
  1343.         { /* If we get an OFFSET_REF, turn it into what it really
  1344.              means (e.g., a COMPONENT_REF).  This way if we've got,
  1345.              say, a reference to a static member that's being operated
  1346.              on, we don't end up trying to find a member operator for
  1347.              the class it's in.  */
  1348.           if (TREE_CODE ($$) == OFFSET_REF)
  1349.             $$ = resolve_offset_ref ($$);
  1350.           $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
  1351.     | primary MINUSMINUS
  1352.         { if (TREE_CODE ($$) == OFFSET_REF)
  1353.             $$ = resolve_offset_ref ($$);
  1354.           $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
  1355.     /* C++ extensions */
  1356.     | THIS
  1357.         { if (current_class_decl)
  1358.             {
  1359. #ifdef WARNING_ABOUT_CCD
  1360.               TREE_USED (current_class_decl) = 1;
  1361. #endif
  1362.               $$ = current_class_decl;
  1363.             }
  1364.           else if (current_function_decl
  1365.                && DECL_STATIC_FUNCTION_P (current_function_decl))
  1366.             {
  1367.               error ("`this' is unavailable for static member functions");
  1368.               $$ = error_mark_node;
  1369.             }
  1370.           else
  1371.             {
  1372.               if (current_function_decl)
  1373.             error ("invalid use of `this' in non-member function");
  1374.               else
  1375.             error ("invalid use of `this' at top level");
  1376.               $$ = error_mark_node;
  1377.             }
  1378.         }
  1379.     | TYPE_QUAL '(' nonnull_exprlist ')'
  1380.         {
  1381.           tree type;
  1382.           tree id = $$;
  1383.  
  1384.           /* This is a C cast in C++'s `functional' notation.  */
  1385.           if ($3 == error_mark_node)
  1386.             {
  1387.               $$ = error_mark_node;
  1388.               break;
  1389.             }
  1390. #if 0
  1391.           if ($3 == NULL_TREE)
  1392.             {
  1393.               error ("cannot cast null list to type `%s'",
  1394.                      IDENTIFIER_POINTER (TYPE_NAME (id)));
  1395.               $$ = error_mark_node;
  1396.               break;
  1397.             }
  1398. #endif
  1399. #if 0
  1400.           /* type is not set! (mrs) */
  1401.           if (type == error_mark_node)
  1402.             $$ = error_mark_node;
  1403.           else
  1404. #endif
  1405.             {
  1406.               if (id == ridpointers[(int) RID_CONST])
  1407.                 type = build_type_variant (integer_type_node, 1, 0);
  1408.               else if (id == ridpointers[(int) RID_VOLATILE])
  1409.                 type = build_type_variant (integer_type_node, 0, 1);
  1410. #if 0
  1411.               /* should not be able to get here (mrs) */
  1412.               else if (id == ridpointers[(int) RID_FRIEND])
  1413.                 {
  1414.                   error ("cannot cast expression to `friend' type");
  1415.                   $$ = error_mark_node;
  1416.                   break;
  1417.                 }
  1418. #endif
  1419.               else my_friendly_abort (79);
  1420.               $$ = build_c_cast (type, build_compound_expr ($3));
  1421.             }
  1422.         }
  1423.     | functional_cast
  1424.     | DYNAMIC_CAST '<' type_id '>' '(' expr ')'
  1425.         { tree type = groktypename ($3);
  1426.           $$ = build_dynamic_cast (type, $6); }
  1427.     | STATIC_CAST '<' type_id '>' '(' expr ')'
  1428.         { tree type = groktypename ($3);
  1429.           $$ = build_static_cast (type, $6); }
  1430.     | REINTERPRET_CAST '<' type_id '>' '(' expr ')'
  1431.         { tree type = groktypename ($3);
  1432.           $$ = build_reinterpret_cast (type, $6); }
  1433.     | CONST_CAST '<' type_id '>' '(' expr ')'
  1434.         { tree type = groktypename ($3);
  1435.           $$ = build_const_cast (type, $6); }
  1436.     | TYPEID '(' expr ')'
  1437.         { $$ = build_typeid ($3); }
  1438.     | TYPEID '(' type_id ')'
  1439.         { tree type = groktypename ($3);
  1440.           $$ = get_typeid (type); }
  1441.     | global_scope IDENTIFIER
  1442.         {
  1443.         do_scoped_id:
  1444.           $$ = IDENTIFIER_GLOBAL_VALUE ($2);
  1445.           if (yychar == YYEMPTY)
  1446.             yychar = YYLEX;
  1447.           if (! $$)
  1448.             {
  1449.               if (yychar == '(' || yychar == LEFT_RIGHT)
  1450.             $$ = implicitly_declare ($2);
  1451.               else
  1452.             {
  1453.               if (IDENTIFIER_GLOBAL_VALUE ($2) != error_mark_node)
  1454.                 error ("undeclared variable `%s' (first use here)",
  1455.                    IDENTIFIER_POINTER ($2));
  1456.               $$ = error_mark_node;
  1457.               /* Prevent repeated error messages.  */
  1458.               IDENTIFIER_GLOBAL_VALUE ($2) = error_mark_node;
  1459.             }
  1460.             }
  1461.           else
  1462.             {
  1463.               if (TREE_CODE ($$) == ADDR_EXPR)
  1464.             assemble_external (TREE_OPERAND ($$, 0));
  1465.               else
  1466.             assemble_external ($$);
  1467.               TREE_USED ($$) = 1;
  1468.             }
  1469.           if (TREE_CODE ($$) == CONST_DECL)
  1470.             {
  1471.               /* XXX CHS - should we set TREE_USED of the constant? */
  1472.               $$ = DECL_INITIAL ($$);
  1473.               /* This is to prevent an enum whose value is 0
  1474.              from being considered a null pointer constant.  */
  1475.               $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$);
  1476.               TREE_CONSTANT ($$) = 1;
  1477.             }
  1478.  
  1479.         }
  1480.     | global_scope operator_name
  1481.         {
  1482.           got_scope = NULL_TREE;
  1483.           if (TREE_CODE ($2) == IDENTIFIER_NODE)
  1484.             goto do_scoped_id;
  1485.           $$ = $2;
  1486.         }
  1487.     | overqualified_id %prec HYPERUNARY
  1488.         { $$ = build_offset_ref (OP0 ($$), OP1 ($$)); }
  1489.     | overqualified_id '(' nonnull_exprlist ')'
  1490.         { $$ = build_member_call (OP0 ($$), OP1 ($$), $3); }
  1491.     | overqualified_id LEFT_RIGHT
  1492.         { $$ = build_member_call (OP0 ($$), OP1 ($$), NULL_TREE); }
  1493.     | object unqualified_id  %prec UNARY
  1494.         { $$ = build_component_ref ($$, $2, NULL_TREE, 1); }
  1495.     | object qualified_id %prec UNARY
  1496.         { $$ = build_object_ref ($$, OP0 ($2), OP1 ($2)); }
  1497.     | object unqualified_id '(' nonnull_exprlist ')'
  1498.         {
  1499. #if 0
  1500.           /* This is a future direction of this code, but because
  1501.              build_x_function_call cannot always undo what is done
  1502.              in build_component_ref entirely yet, we cannot do this. */
  1503.           $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), $4, $$);
  1504.           if (TREE_CODE ($$) == CALL_EXPR
  1505.               && TREE_TYPE ($$) != void_type_node)
  1506.             $$ = require_complete_type ($$);
  1507. #else
  1508.           $$ = build_method_call ($$, $2, $4, NULL_TREE,
  1509.                       (LOOKUP_NORMAL|LOOKUP_AGGR));
  1510. #endif
  1511.         }
  1512.     | object unqualified_id LEFT_RIGHT
  1513.         {
  1514. #if 0
  1515.           /* This is a future direction of this code, but because
  1516.              build_x_function_call cannot always undo what is done
  1517.              in build_component_ref entirely yet, we cannot do this. */
  1518.           $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), NULL_TREE, $$);
  1519.           if (TREE_CODE ($$) == CALL_EXPR
  1520.               && TREE_TYPE ($$) != void_type_node)
  1521.             $$ = require_complete_type ($$);
  1522. #else
  1523.           $$ = build_method_call ($$, $2, NULL_TREE, NULL_TREE,
  1524.                       (LOOKUP_NORMAL|LOOKUP_AGGR));
  1525. #endif
  1526.         }
  1527.     | object qualified_id '(' nonnull_exprlist ')'
  1528.         {
  1529.           if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 ($2))))
  1530.             {
  1531.               warning ("signature name in scope resolution ignored");
  1532.               $$ = build_method_call ($$, OP1 ($2), $4, NULL_TREE,
  1533.                           (LOOKUP_NORMAL|LOOKUP_AGGR));
  1534.             }
  1535.           else
  1536.             $$ = build_scoped_method_call ($$, OP0 ($2), OP1 ($2), $4);
  1537.         }
  1538.     | object qualified_id LEFT_RIGHT
  1539.         {
  1540.           if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 ($2))))
  1541.             {
  1542.               warning ("signature name in scope resolution ignored");
  1543.               $$ = build_method_call ($$, OP1 ($2), NULL_TREE, NULL_TREE,
  1544.                           (LOOKUP_NORMAL|LOOKUP_AGGR));
  1545.             }
  1546.           else
  1547.             $$ = build_scoped_method_call ($$, OP0 ($2), OP1 ($2), NULL_TREE);
  1548.         }
  1549.     /* p->int::~int() is valid -- 12.4 */
  1550.     | object '~' TYPESPEC LEFT_RIGHT
  1551.         { 
  1552.           if (TREE_CODE (TREE_TYPE ($1)) 
  1553.               != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3))))
  1554.             cp_error ("`%E' is not of type `%T'", $1, $3);
  1555.           $$ = convert (void_type_node, $1);
  1556.         }
  1557.     | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT
  1558.         { 
  1559.           if ($2 != $5)
  1560.             cp_error ("destructor specifier `%T::~%T()' must have matching names", $2, $5);
  1561.           if (TREE_CODE (TREE_TYPE ($1))
  1562.               != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($2))))
  1563.             cp_error ("`%E' is not of type `%T'", $1, $2);
  1564.           $$ = convert (void_type_node, $1);
  1565.         }
  1566.     ;
  1567.  
  1568. /* Not needed for now.
  1569.  
  1570. primary_no_id:
  1571.       '(' expr ')'
  1572.         { $$ = $2; }
  1573.     | '(' error ')'
  1574.         { $$ = error_mark_node; }
  1575.     | '('
  1576.         { if (current_function_decl == 0)
  1577.             {
  1578.               error ("braced-group within expression allowed only inside a function");
  1579.               YYERROR;
  1580.             }
  1581.           $<ttype>$ = expand_start_stmt_expr (); }
  1582.       compstmt ')'
  1583.         { if (flag_ansi)
  1584.             pedwarn ("ANSI C++ forbids braced-groups within expressions");
  1585.           $$ = expand_end_stmt_expr ($<ttype>2); }
  1586.     | primary_no_id '(' nonnull_exprlist ')'
  1587.         { $$ = build_x_function_call ($$, $3, current_class_decl); }
  1588.     | primary_no_id LEFT_RIGHT
  1589.         { $$ = build_x_function_call ($$, NULL_TREE, current_class_decl); }
  1590.     | primary_no_id '[' expr ']'
  1591.         { goto do_array; }
  1592.     | primary_no_id PLUSPLUS
  1593.         { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
  1594.     | primary_no_id MINUSMINUS
  1595.         { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
  1596.     | SCOPE IDENTIFIER
  1597.         { goto do_scoped_id; }
  1598.     | SCOPE operator_name
  1599.         { if (TREE_CODE ($2) == IDENTIFIER_NODE)
  1600.             goto do_scoped_id;
  1601.           goto do_scoped_operator;
  1602.         }
  1603.     ;
  1604. */
  1605.  
  1606. new:      NEW
  1607.         { $$ = 0; }
  1608.     | global_scope NEW
  1609.         { got_scope = NULL_TREE; $$ = 1; }
  1610.     ;
  1611.  
  1612. delete:      DELETE
  1613.         { $$ = 0; }
  1614.     | global_scope delete
  1615.         { got_scope = NULL_TREE; $$ = 1; }
  1616.     ;
  1617.  
  1618. boolean.literal:
  1619.       CXX_TRUE
  1620.         { $$ = true_node; }
  1621.     | CXX_FALSE
  1622.         { $$ = false_node; }
  1623.     ;
  1624.  
  1625. /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it.  */
  1626. string:
  1627.       STRING
  1628.     | string STRING
  1629.         { $$ = chainon ($$, $2); }
  1630.     ;
  1631.  
  1632. nodecls:
  1633.       /* empty */
  1634.         {
  1635.           if (! current_function_parms_stored)
  1636.             store_parm_decls ();
  1637.           setup_vtbl_ptr ();
  1638.           /* Always keep the BLOCK node associated with the outermost
  1639.              pair of curley braces of a function.  These are needed
  1640.              for correct operation of dwarfout.c.  */
  1641.           keep_next_level ();
  1642.         }
  1643.     ;
  1644.  
  1645. object:      primary '.'
  1646.     | primary POINTSAT
  1647.         {
  1648.           $$ = build_x_arrow ($$);
  1649.         }
  1650.     ;
  1651.  
  1652. decl:
  1653.     /* Normal case: make this fast.  */
  1654.       typespec declarator ';'
  1655.         { tree d = get_decl_list ($1);
  1656.           int yes = suspend_momentary ();
  1657.           d = start_decl ($2, d, 0, NULL_TREE);
  1658.           finish_decl (d, NULL_TREE, NULL_TREE, 0);
  1659.           resume_momentary (yes);
  1660.           if (IS_AGGR_TYPE_CODE (TREE_CODE ($1)))
  1661.             note_got_semicolon ($1);
  1662.         }
  1663.     | typed_declspecs declarator ';'
  1664.         { tree d = $1;
  1665.           int yes = suspend_momentary ();
  1666.           d = start_decl ($2, d, 0, NULL_TREE);
  1667.           finish_decl (d, NULL_TREE, NULL_TREE, 0);
  1668.           resume_momentary (yes);
  1669.           note_list_got_semicolon ($1);
  1670.         }
  1671.     | typespec initdecls ';'
  1672.         {
  1673.           resume_momentary ($2);
  1674.           if (IS_AGGR_TYPE_CODE (TREE_CODE ($1)))
  1675.             note_got_semicolon ($1);
  1676.         }
  1677.     | typed_declspecs initdecls ';'
  1678.         {
  1679.           resume_momentary ($2);
  1680.           note_list_got_semicolon ($1);
  1681.         }
  1682.     | declmods notype_initdecls ';'
  1683.         { resume_momentary ($2); }
  1684.     | typed_declspecs ';'
  1685.         {
  1686.           shadow_tag ($1);
  1687.           note_list_got_semicolon ($1);
  1688.         }
  1689.     | declmods ';'
  1690.         { warning ("empty declaration"); }
  1691.     ;
  1692.  
  1693. /* Any kind of declarator (thus, all declarators allowed
  1694.    after an explicit typespec).  */
  1695.  
  1696. declarator:
  1697.       after_type_declarator %prec EMPTY
  1698.     | notype_declarator %prec EMPTY
  1699.     ;
  1700.  
  1701. /* This is necessary to postpone reduction of `int()()()()'.  */
  1702. fcast_or_absdcl:
  1703.       LEFT_RIGHT %prec EMPTY
  1704.         { $$ = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (),
  1705.                      NULL_TREE); }
  1706.     | fcast_or_absdcl LEFT_RIGHT %prec EMPTY
  1707.         { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), 
  1708.                      NULL_TREE); }
  1709.     ;
  1710.  
  1711. /* ANSI type-id (8.1) */
  1712. type_id:
  1713.       typed_typespecs absdcl
  1714.         { $$ = build_decl_list ($$, $2); }
  1715.     | nonempty_type_quals absdcl
  1716.         { $$ = build_decl_list ($$, $2); }
  1717.     | typespec absdcl
  1718.         { $$ = build_decl_list (get_decl_list ($$), $2); }
  1719.     | typed_typespecs %prec EMPTY
  1720.         { $$ = build_decl_list ($$, NULL_TREE); }
  1721.     | nonempty_type_quals %prec EMPTY
  1722.         { $$ = build_decl_list ($$, NULL_TREE); }
  1723.     ;
  1724.  
  1725. /* Declspecs which contain at least one type specifier or typedef name.
  1726.    (Just `const' or `volatile' is not enough.)
  1727.    A typedef'd name following these is taken as a name to be declared.  */
  1728.  
  1729. typed_declspecs:
  1730.       typed_typespecs %prec EMPTY
  1731.     | typed_declspecs1
  1732.  
  1733. typed_declspecs1:
  1734.       declmods typespec
  1735.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  1736.     | typespec reserved_declspecs    %prec HYPERUNARY
  1737.         { $$ = decl_tree_cons (NULL_TREE, $$, $2); }
  1738.     | declmods typespec reserved_declspecs
  1739.         { $$ = decl_tree_cons (NULL_TREE, $2, chainon ($3, $$)); }
  1740.     | declmods typespec reserved_typespecquals
  1741.         { $$ = decl_tree_cons (NULL_TREE, $2, chainon ($3, $$)); }
  1742.     | declmods typespec reserved_typespecquals reserved_declspecs
  1743.         { $$ = decl_tree_cons (NULL_TREE, $2, 
  1744.                        chainon ($3, chainon ($4, $$))); }
  1745.     ;
  1746.  
  1747. reserved_declspecs:
  1748.       SCSPEC
  1749.         { if (extra_warnings)
  1750.             warning ("`%s' is not at beginning of declaration",
  1751.                  IDENTIFIER_POINTER ($$));
  1752.           $$ = build_decl_list (NULL_TREE, $$); }
  1753.     | reserved_declspecs typespecqual_reserved
  1754.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  1755.     | reserved_declspecs SCSPEC
  1756.         { if (extra_warnings)
  1757.             warning ("`%s' is not at beginning of declaration",
  1758.                  IDENTIFIER_POINTER ($2));
  1759.           $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  1760.     ;
  1761.  
  1762. /* List of just storage classes and type modifiers.
  1763.    A declaration can start with just this, but then it cannot be used
  1764.    to redeclare a typedef-name.  */
  1765.  
  1766. declmods:
  1767.       nonempty_type_quals %prec EMPTY
  1768.         { TREE_STATIC ($$) = 1; }
  1769.     | SCSPEC
  1770.         { $$ = IDENTIFIER_AS_LIST ($$); }
  1771.     | declmods TYPE_QUAL
  1772.         { $$ = decl_tree_cons (NULL_TREE, $2, $$);
  1773.           TREE_STATIC ($$) = 1; }
  1774.     | declmods SCSPEC
  1775.         { if (extra_warnings && TREE_STATIC ($$))
  1776.             warning ("`%s' is not at beginning of declaration",
  1777.                  IDENTIFIER_POINTER ($2));
  1778.           $$ = decl_tree_cons (NULL_TREE, $2, $$);
  1779.           TREE_STATIC ($$) = TREE_STATIC ($1); }
  1780.     ;
  1781.  
  1782.  
  1783. /* Used instead of declspecs where storage classes are not allowed
  1784.    (that is, for typenames and structure components).
  1785.  
  1786.    C++ can takes storage classes for structure components.
  1787.    Don't accept a typedef-name if anything but a modifier precedes it.  */
  1788.  
  1789. typed_typespecs:
  1790.       typespec  %prec EMPTY
  1791.         { $$ = get_decl_list ($$); }
  1792.     | nonempty_type_quals typespec
  1793.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  1794.     | typespec reserved_typespecquals
  1795.         { $$ = decl_tree_cons (NULL_TREE, $$, $2); }
  1796.     | nonempty_type_quals typespec reserved_typespecquals
  1797.         { $$ = decl_tree_cons (NULL_TREE, $2, chainon ($3, $$)); }
  1798.     ;
  1799.  
  1800. reserved_typespecquals:
  1801.       typespecqual_reserved
  1802.         { $$ = build_decl_list (NULL_TREE, $$); }
  1803.     | reserved_typespecquals typespecqual_reserved
  1804.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  1805.     ;
  1806.  
  1807. /* A typespec (but not a type qualifier).
  1808.    Once we have seen one of these in a declaration,
  1809.    if a typedef name appears then it is being redeclared.  */
  1810.  
  1811. typespec: structsp
  1812.     | TYPESPEC  %prec EMPTY
  1813.     | complete_type_name
  1814.     | TYPEOF '(' expr ')'
  1815.         { $$ = TREE_TYPE ($3);
  1816.           if (flag_ansi)
  1817.             pedwarn ("ANSI C++ forbids `typeof'"); }
  1818.     | TYPEOF '(' type_id ')'
  1819.         { $$ = groktypename ($3);
  1820.           if (flag_ansi)
  1821.             pedwarn ("ANSI C++ forbids `typeof'"); }
  1822.     | SIGOF '(' expr ')'
  1823.         { tree type = TREE_TYPE ($3);
  1824.  
  1825.           if (IS_AGGR_TYPE (type))
  1826.             {
  1827.               sorry ("sigof type specifier");
  1828.               $$ = type;
  1829.             }
  1830.           else
  1831.             {
  1832.               error ("`sigof' applied to non-aggregate expression");
  1833.               $$ = error_mark_node;
  1834.             }
  1835.         }
  1836.     | SIGOF '(' type_id ')'
  1837.         { tree type = groktypename ($3);
  1838.  
  1839.           if (IS_AGGR_TYPE (type))
  1840.             {
  1841.               sorry ("sigof type specifier");
  1842.               $$ = type;
  1843.             }
  1844.           else
  1845.             {
  1846.               error("`sigof' applied to non-aggregate type");
  1847.               $$ = error_mark_node;
  1848.             }
  1849.         }
  1850.     ;
  1851.  
  1852. /* A typespec that is a reserved word, or a type qualifier.  */
  1853.  
  1854. typespecqual_reserved: TYPESPEC
  1855.     | TYPE_QUAL
  1856.     | structsp
  1857.     ;
  1858.  
  1859. initdecls:
  1860.       initdcl0
  1861.     | initdecls ',' initdcl
  1862.     ;
  1863.  
  1864. notype_initdecls:
  1865.       notype_initdcl0
  1866.     | notype_initdecls ',' initdcl
  1867.     ;
  1868.  
  1869. nomods_initdecls:
  1870.       nomods_initdcl0
  1871.     | nomods_initdecls ',' initdcl
  1872.     ;
  1873.  
  1874. maybeasm:
  1875.       /* empty */
  1876.         { $$ = NULL_TREE; }
  1877.     | asm_keyword '(' string ')'
  1878.         { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); $$ = $3; }
  1879.     ;
  1880.  
  1881. initdcl0:
  1882.       declarator maybe_raises maybeasm maybe_attribute '='
  1883.         { current_declspecs = $<ttype>0;
  1884.           if (TREE_CODE (current_declspecs) != TREE_LIST)
  1885.             current_declspecs = get_decl_list (current_declspecs);
  1886.           if (have_extern_spec && !used_extern_spec)
  1887.             {
  1888.               current_declspecs = decl_tree_cons
  1889.             (NULL_TREE, get_identifier ("extern"), 
  1890.              current_declspecs);
  1891.               used_extern_spec = 1;
  1892.             }
  1893.           $<itype>5 = suspend_momentary ();
  1894.           $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
  1895.           cplus_decl_attributes ($<ttype>$, $4); }
  1896.       init
  1897. /* Note how the declaration of the variable is in effect while its init is parsed! */
  1898.         { finish_decl ($<ttype>6, $7, $3, 0);
  1899.           $$ = $<itype>5; }
  1900.     | declarator maybe_raises maybeasm maybe_attribute
  1901.         { tree d;
  1902.           current_declspecs = $<ttype>0;
  1903.           if (TREE_CODE (current_declspecs) != TREE_LIST)
  1904.             current_declspecs = get_decl_list (current_declspecs);
  1905.           if (have_extern_spec && !used_extern_spec)
  1906.             {
  1907.               current_declspecs = decl_tree_cons
  1908.             (NULL_TREE, get_identifier ("extern"), 
  1909.              current_declspecs);
  1910.               used_extern_spec = 1;
  1911.             }
  1912.           $$ = suspend_momentary ();
  1913.           d = start_decl ($<ttype>1, current_declspecs, 0, $2);
  1914.           cplus_decl_attributes (d, $4);
  1915.           finish_decl (d, NULL_TREE, $3, 0); }
  1916.     ;
  1917.  
  1918. initdcl:
  1919.       declarator maybe_raises maybeasm maybe_attribute '='
  1920.         { $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
  1921.           cplus_decl_attributes ($<ttype>$, $4); }
  1922.       init
  1923. /* Note how the declaration of the variable is in effect while its init is parsed! */
  1924.         { finish_decl ($<ttype>6, $7, $3, 0); }
  1925.     | declarator maybe_raises maybeasm maybe_attribute
  1926.         { $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 0, $2);
  1927.           cplus_decl_attributes ($<ttype>$, $4);
  1928.           finish_decl ($<ttype>$, NULL_TREE, $3, 0); }
  1929.     ;
  1930.  
  1931. notype_initdcl0:
  1932.       notype_declarator maybe_raises maybeasm maybe_attribute '='
  1933.         { current_declspecs = $<ttype>0;
  1934.           $<itype>5 = suspend_momentary ();
  1935.           $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
  1936.           cplus_decl_attributes ($<ttype>$, $4); }
  1937.       init
  1938. /* Note how the declaration of the variable is in effect while its init is parsed! */
  1939.         { finish_decl ($<ttype>6, $7, $3, 0);
  1940.           $$ = $<itype>5; }
  1941.     | notype_declarator maybe_raises maybeasm maybe_attribute
  1942.         { tree d;
  1943.           current_declspecs = $<ttype>0;
  1944.           $$ = suspend_momentary ();
  1945.           d = start_decl ($<ttype>1, current_declspecs, 0, $2);
  1946.           cplus_decl_attributes (d, $4);
  1947.           finish_decl (d, NULL_TREE, $3, 0); }
  1948.     ;
  1949.  
  1950. nomods_initdcl0:
  1951.       notype_declarator maybe_raises maybeasm maybe_attribute '='
  1952.         { current_declspecs = NULL_TREE;
  1953.           $<itype>5 = suspend_momentary ();
  1954.           $<ttype>$ = start_decl ($1, current_declspecs, 1, $2);
  1955.           cplus_decl_attributes ($<ttype>$, $4); }
  1956.       init
  1957. /* Note how the declaration of the variable is in effect while its init is parsed! */
  1958.         { finish_decl ($<ttype>6, $7, $3, 0);
  1959.           $$ = $<itype>5; }
  1960.     | notype_declarator maybe_raises maybeasm maybe_attribute
  1961.         { tree d;
  1962.           current_declspecs = NULL_TREE;
  1963.           $$ = suspend_momentary ();
  1964.           d = start_decl ($1, current_declspecs, 0, $2);
  1965.           cplus_decl_attributes (d, $4);
  1966.           finish_decl (d, NULL_TREE, $3, 0); }
  1967.     ;
  1968.  
  1969. /* the * rules are dummies to accept the Apollo extended syntax
  1970.    so that the header files compile. */
  1971. maybe_attribute:
  1972.       /* empty */
  1973.           { $$ = NULL_TREE; }
  1974.     | attributes
  1975.         { $$ = $1; }
  1976.     ;
  1977.  
  1978. attributes:
  1979.       attribute
  1980.         { $$ = $1; }
  1981.     | attributes attribute
  1982.         { $$ = chainon ($1, $2); }
  1983.     ;
  1984.  
  1985. attribute:
  1986.       ATTRIBUTE '(' '(' attribute_list ')' ')'
  1987.         { $$ = $4; }
  1988.     ;
  1989.  
  1990. attribute_list:
  1991.       attrib
  1992.         { $$ = build_tree_list (NULL_TREE, $1); }
  1993.     | attribute_list ',' attrib
  1994.         { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
  1995.     ;
  1996.  
  1997. attrib:
  1998.     /* empty */
  1999.         { $$ = NULL_TREE; }
  2000.     | any_word
  2001.         { $$ = $1; }
  2002.     | any_word '(' IDENTIFIER ')'
  2003.         { $$ = tree_cons ($1, NULL_TREE, build_tree_list (NULL_TREE, $3)); }
  2004.     | any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
  2005.         { $$ = tree_cons ($1, NULL_TREE, tree_cons (NULL_TREE, $3, $5)); }
  2006.     | any_word '(' nonnull_exprlist ')'
  2007.         { $$ = tree_cons ($1, NULL_TREE, $3); }
  2008.     ;
  2009.  
  2010. /* This still leaves out most reserved keywords,
  2011.    shouldn't we include them?  */
  2012.  
  2013. any_word:
  2014.       identifier
  2015.     | SCSPEC
  2016.     | TYPESPEC
  2017.     | TYPE_QUAL
  2018.     ;
  2019.  
  2020. /* A nonempty list of identifiers, including typenames.  */
  2021. identifiers_or_typenames:
  2022.     identifier
  2023.         { $$ = build_tree_list (NULL_TREE, $1); }
  2024.     | identifiers_or_typenames ',' identifier
  2025.         { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
  2026.     ;
  2027.  
  2028. init:
  2029.       expr_no_commas %prec '='
  2030.     | '{' '}'
  2031.         { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
  2032.           TREE_HAS_CONSTRUCTOR ($$) = 1; }
  2033.     | '{' initlist '}'
  2034.         { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
  2035.           TREE_HAS_CONSTRUCTOR ($$) = 1; }
  2036.     | '{' initlist ',' '}'
  2037.         { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
  2038.           TREE_HAS_CONSTRUCTOR ($$) = 1; }
  2039.     | error
  2040.         { $$ = NULL_TREE; }
  2041.     ;
  2042.  
  2043. /* This chain is built in reverse order,
  2044.    and put in forward order where initlist is used.  */
  2045. initlist:
  2046.       init
  2047.         { $$ = build_tree_list (NULL_TREE, $$); }
  2048.     | initlist ',' init
  2049.         { $$ = tree_cons (NULL_TREE, $3, $$); }
  2050.     /* These are for labeled elements.  */
  2051.     | '[' expr_no_commas ']' init
  2052.         { $$ = build_tree_list ($2, $4); }
  2053.     | initlist ',' CASE expr_no_commas ':' init
  2054.         { $$ = tree_cons ($4, $6, $$); }
  2055.     | identifier ':' init
  2056.         { $$ = build_tree_list ($$, $3); }
  2057.     | initlist ',' identifier ':' init
  2058.         { $$ = tree_cons ($3, $5, $$); }
  2059.     ;
  2060.  
  2061. structsp:
  2062.       ENUM identifier '{'
  2063.         { $<itype>3 = suspend_momentary ();
  2064.           $$ = start_enum ($2); }
  2065.       enumlist maybecomma_warn '}'
  2066.         { $$ = finish_enum ($<ttype>4, $5);
  2067.           resume_momentary ((int) $<itype>3);
  2068.           check_for_missing_semicolon ($<ttype>4); }
  2069.     | ENUM identifier '{' '}'
  2070.         { $$ = finish_enum (start_enum ($2), NULL_TREE);
  2071.           check_for_missing_semicolon ($$); }
  2072.     | ENUM '{'
  2073.         { $<itype>2 = suspend_momentary ();
  2074.           $$ = start_enum (make_anon_name ()); }
  2075.       enumlist maybecomma_warn '}'
  2076.         { $$ = finish_enum ($<ttype>3, $4);
  2077.           resume_momentary ((int) $<itype>1);
  2078.           check_for_missing_semicolon ($<ttype>3); }
  2079.     | ENUM '{' '}'
  2080.         { $$ = finish_enum (start_enum (make_anon_name()), NULL_TREE);
  2081.           check_for_missing_semicolon ($$); }
  2082.     | ENUM identifier
  2083.         { $$ = xref_tag (enum_type_node, $2, NULL_TREE, 0); }
  2084.     | ENUM complex_type_name
  2085.         { $$ = xref_tag (enum_type_node, $2, NULL_TREE, 0); }
  2086.  
  2087.     /* C++ extensions, merged with C to avoid shift/reduce conflicts */
  2088.     | class_head left_curly opt.component_decl_list '}'
  2089.         {
  2090.           int semi;
  2091.           tree id;
  2092.  
  2093. #if 0
  2094.           /* Need to rework class nesting in the
  2095.              presence of nested classes, etc.  */
  2096.           shadow_tag (CLASSTYPE_AS_LIST ($$)); */
  2097. #endif
  2098.           if (yychar == YYEMPTY)
  2099.             yychar = YYLEX;
  2100.           semi = yychar == ';';
  2101.           /* finish_struct nukes this anyway; if
  2102.              finish_exception does too, then it can go. */
  2103.           if (semi)
  2104.             note_got_semicolon ($$);
  2105.  
  2106.           if (TREE_CODE ($$) == ENUMERAL_TYPE)
  2107.             /* $$ = $1 from default rule.  */;
  2108.           else if (CLASSTYPE_DECLARED_EXCEPTION ($$))
  2109.             {
  2110.             }
  2111.           else
  2112.             {
  2113.               $$ = finish_struct ($$, $3, semi);
  2114.               if (semi) note_got_semicolon ($$);
  2115.             }
  2116.  
  2117.           pop_obstacks ();
  2118.  
  2119.           id = TYPE_IDENTIFIER ($$);
  2120.           if (id && IDENTIFIER_TEMPLATE (id))
  2121.             {
  2122.               tree decl;
  2123.  
  2124.               /* I don't know if the copying of this TYPE_DECL is
  2125.                * really needed.  However, it's such a small per-
  2126.                * formance penalty that the extra safety is a bargain.
  2127.                * - niklas@appli.se
  2128.                */
  2129.               push_obstacks (&permanent_obstack, &permanent_obstack);
  2130.               decl = copy_node (lookup_name (id, 0));
  2131.               if (DECL_LANG_SPECIFIC (decl))
  2132.             copy_lang_decl (decl);
  2133.               pop_obstacks ();
  2134.               undo_template_name_overload (id, 0);
  2135.               pushdecl_top_level (decl);
  2136.             }
  2137.           if (! semi)
  2138.             check_for_missing_semicolon ($$); }
  2139.     | class_head  %prec EMPTY
  2140.         {
  2141. #if 0
  2142.   /* It's no longer clear what the following error is supposed to
  2143.      accomplish.  If it turns out to be needed, add a comment why.  */
  2144.           if (TYPE_BINFO_BASETYPES ($$) && !TYPE_SIZE ($$))
  2145.             {
  2146.               error ("incomplete definition of type `%s'",
  2147.                  TYPE_NAME_STRING ($$));
  2148.               $$ = error_mark_node;
  2149.             }
  2150. #endif
  2151.         }
  2152.     ;
  2153.  
  2154. maybecomma:
  2155.       /* empty */
  2156.     | ','
  2157.     ;
  2158.  
  2159. maybecomma_warn:
  2160.       /* empty */
  2161.     | ','
  2162.         { if (pedantic) pedwarn ("comma at end of enumerator list"); }
  2163.     ;
  2164.  
  2165. aggr:      AGGR
  2166.     | aggr SCSPEC
  2167.         { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
  2168.     | aggr TYPESPEC
  2169.         { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
  2170.     | aggr TYPE_QUAL
  2171.         { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
  2172.     | aggr AGGR
  2173.         { error ("no body nor ';' separates two class, struct or union declarations"); }
  2174.     ;
  2175.  
  2176. specialization:
  2177.       aggr template_type_name ';'
  2178.         { 
  2179.           yyungetc (';', 1); current_aggr = $$; $$ = $2; 
  2180.           if ($<ttype>0 == ridpointers[(int) RID_TEMPLATE])
  2181.             instantiate_class_template ($$, 2);
  2182.         }
  2183.     ;
  2184.  
  2185. named_class_head_sans_basetype:
  2186.       aggr identifier
  2187.         { current_aggr = $$; $$ = $2; }
  2188.     | aggr complex_type_name
  2189.         { current_aggr = $$; $$ = $2; }
  2190.     | aggr template_type %prec EMPTY
  2191.         { current_aggr = $$; $$ = $2; }
  2192.     | aggr template_type_name '{'
  2193.         { yyungetc ('{', 1);
  2194.         aggr2:
  2195.           current_aggr = $$;
  2196.           $$ = $2;
  2197.           overload_template_name ($$, 0); }
  2198.     | aggr template_type_name ':'
  2199.         { yyungetc (':', 1); goto aggr2; }
  2200.     | specialization
  2201.     ;
  2202.  
  2203. named_class_head_sans_basetype_defn:
  2204.       aggr identifier_defn %prec EMPTY
  2205.         { current_aggr = $$; $$ = $2; }
  2206.     ;
  2207.  
  2208. do_xref: /* empty */ %prec EMPTY
  2209.     { $<ttype>$ = xref_tag (current_aggr, $<ttype>0, NULL_TREE, 1); }
  2210.  
  2211. do_xref_defn: /* empty */ %prec EMPTY
  2212.     { $<ttype>$ = xref_defn_tag (current_aggr, $<ttype>0, NULL_TREE); }
  2213.  
  2214. named_class_head:
  2215.       named_class_head_sans_basetype do_xref
  2216.       maybe_base_class_list %prec EMPTY
  2217.         {
  2218.           if ($3)
  2219.             $$ = xref_tag (current_aggr, $1, $3, 1);
  2220.           else
  2221.             $$ = $<ttype>2;
  2222.         }
  2223.     |
  2224.       named_class_head_sans_basetype_defn do_xref_defn
  2225.       maybe_base_class_list %prec EMPTY
  2226.         {
  2227.           if ($3)
  2228.             $$ = xref_defn_tag (current_aggr, $1, $3);
  2229.           else
  2230.             $$ = $<ttype>2;
  2231.         }
  2232.     ;
  2233.  
  2234. unnamed_class_head: aggr '{'
  2235.         { $$ = xref_tag ($$, make_anon_name (), NULL_TREE, 0);
  2236.           yyungetc ('{', 1); }
  2237.     ;
  2238.  
  2239. class_head: unnamed_class_head | named_class_head ;
  2240.  
  2241. maybe_base_class_list:
  2242.       %prec EMPTY /* empty */
  2243.         { $$ = NULL_TREE; }
  2244.     | ':'  %prec EMPTY
  2245.         { yyungetc(':', 1); $$ = NULL_TREE; }
  2246.     | ':' base_class_list  %prec EMPTY
  2247.         { $$ = $2; }
  2248.     ;
  2249.  
  2250. base_class_list:
  2251.       base_class
  2252.     | base_class_list ',' base_class
  2253.         { $$ = chainon ($$, $3); }
  2254.     ;
  2255.  
  2256. base_class:
  2257.       base_class.1
  2258.         {
  2259.           tree type;
  2260.          do_base_class1:
  2261.           type = IDENTIFIER_TYPE_VALUE ($$);
  2262.           if (! is_aggr_typedef ($$, 1))
  2263.             $$ = NULL_TREE;
  2264.           else if (current_aggr == signature_type_node
  2265.                && (! type) && (! IS_SIGNATURE (type)))
  2266.             {
  2267.               error ("class name not allowed as base signature");
  2268.               $$ = NULL_TREE;
  2269.             }
  2270.           else if (current_aggr == signature_type_node)
  2271.             {
  2272.               sorry ("signature inheritance, base type `%s' ignored",
  2273.                  IDENTIFIER_POINTER ($$));
  2274.               $$ = build_tree_list ((tree)access_public, $$);
  2275.             }
  2276.           else if (type && IS_SIGNATURE (type))
  2277.             {
  2278.               error ("signature name not allowed as base class");
  2279.               $$ = NULL_TREE;
  2280.             }
  2281.           else
  2282.             $$ = build_tree_list ((tree)access_default, $$);
  2283.         }
  2284.     | base_class_access_list base_class.1
  2285.         {
  2286.           tree type;
  2287.          do_base_class2:
  2288.           type = IDENTIFIER_TYPE_VALUE ($2);
  2289.           if (current_aggr == signature_type_node)
  2290.             error ("access and source specifiers not allowed in signature");
  2291.           if (! is_aggr_typedef ($2, 1))
  2292.             $$ = NULL_TREE;
  2293.           else if (current_aggr == signature_type_node
  2294.                && (! type) && (! IS_SIGNATURE (type)))
  2295.             {
  2296.               error ("class name not allowed as base signature");
  2297.               $$ = NULL_TREE;
  2298.             }
  2299.           else if (current_aggr == signature_type_node)
  2300.             {
  2301.               sorry ("signature inheritance, base type `%s' ignored",
  2302.                  IDENTIFIER_POINTER ($$));
  2303.               $$ = build_tree_list ((tree)access_public, $2);
  2304.             }
  2305.           else if (type && IS_SIGNATURE (type))
  2306.             {
  2307.               error ("signature name not allowed as base class");
  2308.               $$ = NULL_TREE;
  2309.             }
  2310.           else
  2311.             $$ = build_tree_list ((tree) $$, $2);
  2312.         }
  2313.     ;
  2314.  
  2315. base_class.1:
  2316.       complete_type_name
  2317.     | SIGOF '(' expr ')'
  2318.         {
  2319.           if (current_aggr == signature_type_node)
  2320.             {
  2321.               if (IS_AGGR_TYPE (TREE_TYPE ($3)))
  2322.             {
  2323.               sorry ("`sigof' as base signature specifier");
  2324.               /* need to return some dummy signature identifier */
  2325.               $$ = $3;
  2326.             }
  2327.               else
  2328.             {
  2329.               error ("`sigof' applied to non-aggregate expression");
  2330.               $$ = error_mark_node;
  2331.             }
  2332.             }
  2333.           else
  2334.             {
  2335.               error ("`sigof' in struct or class declaration");
  2336.               $$ = error_mark_node;
  2337.             }
  2338.         }
  2339.     | SIGOF '(' type_id ')'
  2340.         {
  2341.           if (current_aggr == signature_type_node)
  2342.             {
  2343.               if (IS_AGGR_TYPE (groktypename ($3)))
  2344.             {
  2345.               sorry ("`sigof' as base signature specifier");
  2346.               /* need to return some dummy signature identifier */
  2347.               $$ = $3;
  2348.             }
  2349.               else
  2350.             {
  2351.               error ("`sigof' applied to non-aggregate expression");
  2352.               $$ = error_mark_node;
  2353.             }
  2354.             }
  2355.           else
  2356.             {
  2357.               error ("`sigof' in struct or class declaration");
  2358.               $$ = error_mark_node;
  2359.             }
  2360.         }
  2361.     ;
  2362.  
  2363. base_class_access_list:
  2364.       VISSPEC
  2365.     | SCSPEC
  2366.         { if ($<ttype>$ != ridpointers[(int)RID_VIRTUAL])
  2367.             sorry ("non-virtual access");
  2368.           $$ = access_default_virtual; }
  2369.     | base_class_access_list VISSPEC
  2370.         { int err = 0;
  2371.           if ($2 == access_protected)
  2372.             {
  2373.               warning ("`protected' access not implemented");
  2374.               $2 = access_public;
  2375.               err++;
  2376.             }
  2377.           else if ($2 == access_public)
  2378.             {
  2379.               if ($1 == access_private)
  2380.             {
  2381.             mixed:
  2382.               error ("base class cannot be public and private");
  2383.             }
  2384.               else if ($1 == access_default_virtual)
  2385.             $$ = access_public_virtual;
  2386.             }
  2387.           else /* $2 == access_private */
  2388.             {
  2389.               if ($1 == access_public)
  2390.             goto mixed;
  2391.               else if ($1 == access_default_virtual)
  2392.             $$ = access_private_virtual;
  2393.             }
  2394.         }
  2395.     | base_class_access_list SCSPEC
  2396.         { if ($2 != ridpointers[(int)RID_VIRTUAL])
  2397.             sorry ("non-virtual access");
  2398.           if ($$ == access_public)
  2399.             $$ = access_public_virtual;
  2400.           else if ($$ == access_private)
  2401.             $$ = access_private_virtual; }
  2402.     ;
  2403.  
  2404. left_curly: '{'
  2405.         { tree t = $<ttype>0;
  2406.           push_obstacks_nochange ();
  2407.           end_temporary_allocation ();
  2408.  
  2409.           if (! IS_AGGR_TYPE (t))
  2410.             {
  2411.               t = $<ttype>0 = make_lang_type (RECORD_TYPE);
  2412.               TYPE_NAME (t) = get_identifier ("erroneous type");
  2413.             }
  2414.           if (TYPE_SIZE (t))
  2415.             duplicate_tag_error (t);
  2416.                   if (TYPE_SIZE (t) || TYPE_BEING_DEFINED (t))
  2417.                     {
  2418.                       t = make_lang_type (TREE_CODE (t));
  2419.                       pushtag (TYPE_IDENTIFIER ($<ttype>0), t, 0);
  2420.                       $<ttype>0 = t;
  2421.                     }
  2422.           pushclass (t, 0);
  2423.           TYPE_BEING_DEFINED (t) = 1;
  2424.           /* Reset the interface data, at the earliest possible
  2425.              moment, as it might have been set via a class foo;
  2426.              before.  */
  2427.           /* Don't change signatures.  */
  2428.           if (! IS_SIGNATURE (t))
  2429.             {
  2430.               extern tree pending_vtables;
  2431.               int needs_writing;
  2432.               tree name = TYPE_IDENTIFIER (t);
  2433.  
  2434.               CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
  2435.               SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
  2436.  
  2437.               /* Record how to set the access of this class's
  2438.              virtual functions.  If write_virtuals == 2 or 3, then
  2439.              inline virtuals are ``extern inline''.  */
  2440.               switch (write_virtuals)
  2441.             {
  2442.             case 0:
  2443.             case 1:
  2444.               needs_writing = 1;
  2445.               break;
  2446.             case 2:
  2447.               needs_writing = !! value_member (name, pending_vtables);
  2448.               break;
  2449.             case 3:
  2450.               needs_writing = ! CLASSTYPE_INTERFACE_ONLY (t)
  2451.                 && CLASSTYPE_INTERFACE_KNOWN (t);
  2452.               break;
  2453.             default:
  2454.               needs_writing = 0;
  2455.             }
  2456.               CLASSTYPE_VTABLE_NEEDS_WRITING (t) = needs_writing;
  2457.             }
  2458. #if 0
  2459.           t = TYPE_IDENTIFIER ($<ttype>0);
  2460.           if (t && IDENTIFIER_TEMPLATE (t))
  2461.             overload_template_name (t, 1);
  2462. #endif
  2463.         }
  2464.     ;
  2465.  
  2466. opt.component_decl_list:
  2467.     /* empty */
  2468.         { $$ = NULL_TREE; }
  2469.     | component_decl_list
  2470.         {
  2471.           if (current_aggr == signature_type_node)
  2472.             $$ = build_tree_list ((tree) access_public, $$);
  2473.           else
  2474.             $$ = build_tree_list ((tree) access_default, $$);
  2475.         }
  2476.     | opt.component_decl_list VISSPEC ':' component_decl_list
  2477.         {
  2478.           tree visspec = (tree) $2;
  2479.  
  2480.           if (current_aggr == signature_type_node)
  2481.             {
  2482.               error ("access specifier not allowed in signature");
  2483.               visspec = (tree) access_public;
  2484.             }
  2485.           $$ = chainon ($$, build_tree_list (visspec, $4));
  2486.         }
  2487.     | opt.component_decl_list VISSPEC ':'
  2488.         {
  2489.           if (current_aggr == signature_type_node)
  2490.             error ("access specifier not allowed in signature");
  2491.         }
  2492.     ;
  2493.  
  2494. /* Note: we no longer warn about the semicolon after a component_decl_list.
  2495.    ARM $9.2 says that the semicolon is optional, and therefore allowed.  */
  2496. component_decl_list:
  2497.       component_decl
  2498.         { if ($$ == void_type_node) $$ = NULL_TREE; 
  2499.         }
  2500.     | component_decl_list component_decl
  2501.         { /* In pushdecl, we created a reverse list of names
  2502.              in this binding level.  Make sure that the chain
  2503.              of what we're trying to add isn't the item itself
  2504.              (which can happen with what pushdecl's doing).  */
  2505.           if ($2 != NULL_TREE && $2 != void_type_node)
  2506.             {
  2507.               if (TREE_CHAIN ($2) != $$)
  2508.             $$ = chainon ($$, $2);
  2509.               else
  2510.             $$ = $2;
  2511.             }
  2512.         }
  2513.     | component_decl_list ';'
  2514.     ;
  2515.  
  2516. component_decl:
  2517.       component_decl_1 ';'
  2518.     | component_decl_1 '}'
  2519.         { error ("missing ';' before right brace");
  2520.           yyungetc ('}', 0); }
  2521.     /* C++: handle constructors, destructors and inline functions */
  2522.     /* note that INLINE is like a TYPESPEC */
  2523.     | fn.def2 ':' /* base_init compstmt */
  2524.         { $$ = finish_method ($$); }
  2525.     | fn.def2 '{' /* nodecls compstmt */
  2526.         { $$ = finish_method ($$); }
  2527.     ;
  2528.  
  2529. component_decl_1:
  2530.     /* Do not add a "typed_declspecs declarator" rule here for
  2531.        speed; we need to call grok_x_components for enums, so the
  2532.        speedup would be insignificant.  */
  2533.       typed_declspecs components
  2534.         {
  2535.           $$ = grok_x_components ($$, $2);
  2536.         }
  2537.     | declmods notype_components
  2538.         { 
  2539.           $$ = grok_x_components ($$, $2);
  2540.         }
  2541.     | notype_declarator maybe_raises maybeasm maybe_attribute
  2542.         { $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, $3);
  2543.           cplus_decl_attributes ($$, $4); }
  2544.     | ':' expr_no_commas
  2545.         { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
  2546.     | error
  2547.         { $$ = NULL_TREE; }
  2548.  
  2549.     /* These rules introduce a reduce/reduce conflict; in
  2550.         typedef int foo, bar;
  2551.         class A {
  2552.           foo (bar);
  2553.         };
  2554.        should "A::foo" be declared as a function or "A::bar" as a data
  2555.        member? In other words, is "bar" an after_type_declarator or a
  2556.        parmlist? */
  2557.     | typed_declspecs '(' parmlist ')' type_quals
  2558.         { $$ = build_parse_node (CALL_EXPR, TREE_VALUE ($1),
  2559.                      $3, $5);
  2560.           $$ = grokfield ($$, TREE_CHAIN ($1), NULL_TREE, NULL_TREE,
  2561.                   NULL_TREE); }
  2562.     | typed_declspecs LEFT_RIGHT type_quals
  2563.         { $$ = build_parse_node (CALL_EXPR, TREE_VALUE ($1),
  2564.                      empty_parms (), $3);
  2565.           $$ = grokfield ($$, TREE_CHAIN ($1), NULL_TREE, NULL_TREE,
  2566.                   NULL_TREE); }
  2567.     ;
  2568.  
  2569. /* The case of exactly one component is handled directly by component_decl. */
  2570. components:
  2571.       /* empty: possibly anonymous */
  2572.         { $$ = NULL_TREE; }
  2573.     | component_declarator0
  2574.     | components ',' component_declarator
  2575.         {
  2576.           /* In this context, void_type_node encodes
  2577.              friends.  They have been recorded elsewhere.  */
  2578.           if ($$ == void_type_node)
  2579.             $$ = $3;
  2580.           else
  2581.             $$ = chainon ($$, $3);
  2582.         }
  2583.     ;
  2584.  
  2585. notype_components:
  2586.       /* empty: possibly anonymous */
  2587.         { $$ = NULL_TREE; }
  2588.     | notype_component_declarator0
  2589.     | notype_components ',' notype_component_declarator
  2590.         {
  2591.           /* In this context, void_type_node encodes
  2592.              friends.  They have been recorded elsewhere.  */
  2593.           if ($$ == void_type_node)
  2594.             $$ = $3;
  2595.           else
  2596.             $$ = chainon ($$, $3);
  2597.         }
  2598.     ;
  2599.  
  2600. component_declarator0:
  2601.       after_type_component_declarator0
  2602.     | notype_component_declarator0
  2603.     ;
  2604.  
  2605. component_declarator:
  2606.       after_type_component_declarator
  2607.     | notype_component_declarator
  2608.     ;
  2609.  
  2610. after_type_component_declarator0:
  2611.       after_type_declarator maybe_raises maybeasm maybe_attribute
  2612.         { current_declspecs = $<ttype>0;
  2613.           $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
  2614.           cplus_decl_attributes ($$, $4); }
  2615.     | after_type_declarator maybe_raises maybeasm maybe_attribute '=' init
  2616.         { current_declspecs = $<ttype>0;
  2617.           $$ = grokfield ($$, current_declspecs, $2, $6, $3);
  2618.           cplus_decl_attributes ($$, $4); }
  2619.     | TYPENAME ':' expr_no_commas maybe_attribute
  2620.         { current_declspecs = $<ttype>0;
  2621.           $$ = grokbitfield ($$, current_declspecs, $3);
  2622.           cplus_decl_attributes ($$, $4); }
  2623.     ;
  2624.  
  2625. notype_component_declarator0:
  2626.       notype_declarator maybe_raises maybeasm maybe_attribute
  2627.         { current_declspecs = $<ttype>0;
  2628.           $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
  2629.           cplus_decl_attributes ($$, $4); }
  2630.     | notype_declarator maybe_raises maybeasm maybe_attribute '=' init
  2631.         { current_declspecs = $<ttype>0;
  2632.           $$ = grokfield ($$, current_declspecs, $2, $6, $3);
  2633.           cplus_decl_attributes ($$, $4); }
  2634.     | IDENTIFIER ':' expr_no_commas maybe_attribute
  2635.         { current_declspecs = $<ttype>0;
  2636.           $$ = grokbitfield ($$, current_declspecs, $3);
  2637.           cplus_decl_attributes ($$, $4); }
  2638.     | ':' expr_no_commas maybe_attribute
  2639.         { current_declspecs = $<ttype>0;
  2640.           $$ = grokbitfield (NULL_TREE, current_declspecs, $2);
  2641.           cplus_decl_attributes ($$, $3); }
  2642.     ;
  2643.  
  2644. after_type_component_declarator:
  2645.       after_type_declarator maybe_raises maybeasm maybe_attribute
  2646.         { $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
  2647.           cplus_decl_attributes ($$, $4); }
  2648.     | after_type_declarator maybe_raises maybeasm maybe_attribute '=' init
  2649.         { $$ = grokfield ($$, current_declspecs, $2, $6, $3);
  2650.           cplus_decl_attributes ($$, $4); }
  2651.     | TYPENAME ':' expr_no_commas maybe_attribute
  2652.         { $$ = grokbitfield ($$, current_declspecs, $3);
  2653.           cplus_decl_attributes ($$, $4); }
  2654.     ;
  2655.  
  2656. notype_component_declarator:
  2657.       notype_declarator maybe_raises maybeasm maybe_attribute
  2658.         { $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
  2659.           cplus_decl_attributes ($$, $4); }
  2660.     | notype_declarator maybe_raises maybeasm maybe_attribute '=' init
  2661.         { $$ = grokfield ($$, current_declspecs, $2, $6, $3);
  2662.           cplus_decl_attributes ($$, $4); }
  2663.     | IDENTIFIER ':' expr_no_commas maybe_attribute
  2664.         { $$ = grokbitfield ($$, current_declspecs, $3);
  2665.           cplus_decl_attributes ($$, $4); }
  2666.     | ':' expr_no_commas maybe_attribute
  2667.         { $$ = grokbitfield (NULL_TREE, current_declspecs, $2);
  2668.           cplus_decl_attributes ($$, $3); }
  2669.     ;
  2670.  
  2671. /* We chain the enumerators in reverse order.
  2672.    Because of the way enums are built, the order is
  2673.    insignificant.  Take advantage of this fact.  */
  2674.  
  2675. enumlist:
  2676.       enumerator
  2677.     | enumlist ',' enumerator
  2678.         { TREE_CHAIN ($3) = $$; $$ = $3; }
  2679.     ;
  2680.  
  2681. enumerator:
  2682.       identifier
  2683.         { $$ = build_enumerator ($$, NULL_TREE); }
  2684.     | identifier '=' expr_no_commas
  2685.         { $$ = build_enumerator ($$, $3); }
  2686.     ;
  2687.  
  2688. /* ANSI new-type-id (5.3.4) */
  2689. new_type_id:
  2690.       type_specifier_seq new_declarator
  2691.         { $$ = build_decl_list ($$, $2); }
  2692.     | type_specifier_seq %prec EMPTY
  2693.         { $$ = build_decl_list ($$, NULL_TREE); }
  2694.     /* GNU extension to allow arrays of arbitrary types with
  2695.        non-constant dimension.  */
  2696.     | '(' type_id ')' '[' expr ']'
  2697.         {
  2698.           if (flag_ansi)
  2699.             pedwarn ("ANSI C++ forbids array dimensions with parenthesized type in new");
  2700.           $$ = build_parse_node (ARRAY_REF, TREE_VALUE ($2), $5);
  2701.           $$ = build_decl_list (TREE_PURPOSE ($2), $$);
  2702.         }
  2703.     ;
  2704.  
  2705. type_quals:
  2706.       /* empty */ %prec EMPTY
  2707.         { $$ = NULL_TREE; }
  2708.     | type_quals TYPE_QUAL
  2709.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  2710.     ;
  2711.  
  2712. nonempty_type_quals:
  2713.       TYPE_QUAL
  2714.         { $$ = IDENTIFIER_AS_LIST ($$); }
  2715.     | nonempty_type_quals TYPE_QUAL
  2716.         { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
  2717.     ;
  2718.  
  2719. /* These rules must follow the rules for function declarations
  2720.    and component declarations.  That way, longer rules are preferred.  */
  2721.  
  2722. /* An expression which will not live on the momentary obstack.  */
  2723. nonmomentary_expr:
  2724.     { $<itype>$ = suspend_momentary (); } expr
  2725.     { resume_momentary ((int) $<itype>1); $$ = $2; }
  2726.     ;
  2727.  
  2728. /* A declarator that is allowed only after an explicit typespec.  */
  2729. /* may all be followed by prec '.' */
  2730. after_type_declarator:
  2731.       '*' nonempty_type_quals after_type_declarator  %prec UNARY
  2732.         { $$ = make_pointer_declarator ($2, $3); }
  2733.     | '&' nonempty_type_quals after_type_declarator  %prec UNARY
  2734.         { $$ = make_reference_declarator ($2, $3); }
  2735.     | '*' after_type_declarator  %prec UNARY
  2736.         { $$ = make_pointer_declarator (NULL_TREE, $2); }
  2737.     | '&' after_type_declarator  %prec UNARY
  2738.         { $$ = make_reference_declarator (NULL_TREE, $2); }
  2739.     | ptr_to_mem type_quals after_type_declarator
  2740.         { tree arg = make_pointer_declarator ($2, $3);
  2741.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2742.         }
  2743.     | direct_after_type_declarator
  2744.     ;
  2745.  
  2746. qualified_type_name:
  2747.       type_name %prec EMPTY
  2748.         {
  2749.           /* Remember that this name has been used in the class
  2750.              definition, as per [class.scope0] */
  2751.           if (current_class_type
  2752.               && TYPE_BEING_DEFINED (current_class_type)
  2753.               && ! IDENTIFIER_CLASS_VALUE ($$))
  2754.             {
  2755.               tree t = lookup_name ($$, -2);
  2756.               if (t)
  2757.             pushdecl_class_level (t);
  2758.             }
  2759.         }
  2760.     | nested_type
  2761.     ;
  2762.  
  2763. nested_type:
  2764.     nested_name_specifier type_name %prec EMPTY
  2765.         { $$ = $2; }
  2766.     ;
  2767.  
  2768. direct_after_type_declarator:
  2769.       direct_after_type_declarator '(' nonnull_exprlist ')' type_quals %prec '.'
  2770.         { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
  2771.     | direct_after_type_declarator '(' parmlist ')' type_quals %prec '.'
  2772.         { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
  2773.     | direct_after_type_declarator LEFT_RIGHT type_quals %prec '.'
  2774.         { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
  2775.     | direct_after_type_declarator '(' error ')' type_quals %prec '.'
  2776.         { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
  2777.     | direct_after_type_declarator '[' nonmomentary_expr ']'
  2778.         { $$ = build_parse_node (ARRAY_REF, $$, $3); }
  2779.     | direct_after_type_declarator '[' ']'
  2780.         { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
  2781.     | '(' after_type_declarator ')'
  2782.         { $$ = $2; }
  2783.     | nested_name_specifier type_name %prec EMPTY
  2784.         { push_nested_class (TREE_TYPE ($$), 3);
  2785.           $$ = build_parse_node (SCOPE_REF, $$, $2);
  2786.           TREE_COMPLEXITY ($$) = current_class_depth; }
  2787.     | type_name %prec EMPTY
  2788.     ;
  2789.  
  2790. /* A declarator allowed whether or not there has been
  2791.    an explicit typespec.  These cannot redeclare a typedef-name.  */
  2792.  
  2793. notype_declarator:
  2794.       '*' nonempty_type_quals notype_declarator  %prec UNARY
  2795.         { $$ = make_pointer_declarator ($2, $3); }
  2796.     | '&' nonempty_type_quals notype_declarator  %prec UNARY
  2797.         { $$ = make_reference_declarator ($2, $3); }
  2798.     | '*' notype_declarator  %prec UNARY
  2799.         { $$ = make_pointer_declarator (NULL_TREE, $2); }
  2800.     | '&' notype_declarator  %prec UNARY
  2801.         { $$ = make_reference_declarator (NULL_TREE, $2); }
  2802.     | ptr_to_mem type_quals notype_declarator
  2803.         { tree arg = make_pointer_declarator ($2, $3);
  2804.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2805.         }
  2806.     | direct_notype_declarator
  2807.     ;
  2808.  
  2809. complex_notype_declarator:
  2810.       '*' nonempty_type_quals notype_declarator  %prec UNARY
  2811.         { $$ = make_pointer_declarator ($2, $3); }
  2812.     | '&' nonempty_type_quals notype_declarator  %prec UNARY
  2813.         { $$ = make_reference_declarator ($2, $3); }
  2814.     | '*' complex_notype_declarator  %prec UNARY
  2815.         { $$ = make_pointer_declarator (NULL_TREE, $2); }
  2816.     | '&' complex_notype_declarator  %prec UNARY
  2817.         { $$ = make_reference_declarator (NULL_TREE, $2); }
  2818.     | ptr_to_mem type_quals notype_declarator
  2819.         { tree arg = make_pointer_declarator ($2, $3);
  2820.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2821.         }
  2822.     | complex_direct_notype_declarator
  2823.     ;
  2824.  
  2825. complex_direct_notype_declarator:
  2826.       direct_notype_declarator '(' nonnull_exprlist ')' type_quals  %prec '.'
  2827.         { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
  2828.     | direct_notype_declarator '(' parmlist ')' type_quals  %prec '.'
  2829.         { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
  2830.     | direct_notype_declarator LEFT_RIGHT type_quals  %prec '.'
  2831.         { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
  2832.     | direct_notype_declarator '(' error ')' type_quals  %prec '.'
  2833.         { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
  2834.     | '(' expr_or_declarator ')'
  2835.         { $$ = finish_decl_parsing ($2); }
  2836.     | '(' complex_notype_declarator ')'
  2837.         { $$ = $2; }
  2838.     | direct_notype_declarator '[' nonmomentary_expr ']'
  2839.         { $$ = build_parse_node (ARRAY_REF, $$, $3); }
  2840.     | direct_notype_declarator '[' ']'
  2841.         { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
  2842.     ;
  2843.  
  2844. qualified_id:
  2845.     nested_name_specifier unqualified_id
  2846.         { got_scope = NULL_TREE;
  2847.           $$ = build_parse_node (SCOPE_REF, $$, $2); }
  2848.     ;
  2849.  
  2850. notype_qualified_id:
  2851.     nested_name_specifier notype_unqualified_id
  2852.         { got_scope = NULL_TREE;
  2853.           $$ = build_parse_node (SCOPE_REF, $$, $2); }
  2854.     ;
  2855.  
  2856. overqualified_id:
  2857.       notype_qualified_id
  2858.     | global_scope notype_qualified_id
  2859.         { $$ = $2; }
  2860.     ;
  2861.  
  2862. functional_cast:
  2863.       typespec '(' nonnull_exprlist ')'
  2864.         { $$ = build_functional_cast ($$, $3); }
  2865.     | typespec '(' expr_or_declarator ')'
  2866.         { $$ = reparse_decl_as_expr ($$, $3); }
  2867.     | typespec fcast_or_absdcl %prec EMPTY
  2868.         { $$ = reparse_absdcl_as_expr ($$, $2); }
  2869.     ;
  2870.  
  2871. type_name:
  2872.       TYPENAME
  2873.     | template_type %prec EMPTY
  2874.     ;
  2875.  
  2876. nested_name_specifier:
  2877.       nested_name_specifier_1
  2878.     | nested_name_specifier nested_name_specifier_1
  2879.         { $$ = $2; }
  2880.     ;
  2881.  
  2882. /* Why the @#$%^& do type_name and notype_identifier need to be expanded
  2883.    inline here?!?  (jason) */
  2884. nested_name_specifier_1:
  2885.       TYPENAME SCOPE
  2886.         { got_scope = TREE_TYPE ($$); }
  2887.     | template_type SCOPE
  2888.         { got_scope = TREE_TYPE ($$); }
  2889. /*     These break 'const i;'
  2890.     | IDENTIFIER SCOPE
  2891.         {
  2892.          failed_scope:
  2893.           cp_error ("`%D' is not an aggregate typedef", 
  2894.                 lastiddecl ? lastiddecl : $$);
  2895.           $$ = error_mark_node;
  2896.         }
  2897.     | PTYPENAME SCOPE
  2898.         { goto failed_scope; } */
  2899.     ;
  2900.  
  2901. complete_type_name:
  2902.       qualified_type_name
  2903.     | global_scope qualified_type_name
  2904.         { $$ = $2; }
  2905.     ;
  2906.  
  2907. complex_type_name:
  2908.       nested_type
  2909.     | global_scope qualified_type_name
  2910.         { $$ = $2; }
  2911.     ;
  2912.  
  2913. ptr_to_mem:
  2914.       nested_name_specifier '*'
  2915.         { got_scope = NULL_TREE; }
  2916.     | global_scope nested_name_specifier '*'
  2917.         { $$ = $2; got_scope = NULL_TREE; }
  2918.     ;
  2919.  
  2920. /* All uses of explicit global scope must go through this nonterminal so
  2921.    that got_scope will be set before yylex is called to get the next token. */
  2922. global_scope:
  2923.       SCOPE
  2924.         { got_scope = void_type_node; }
  2925.     ;
  2926.  
  2927. /* ANSI new-declarator (5.3.4) */
  2928. new_declarator:
  2929.       '*' type_quals new_declarator
  2930.         { $$ = make_pointer_declarator ($2, $3); }
  2931.     | '*' type_quals  %prec EMPTY
  2932.         { $$ = make_pointer_declarator ($2, NULL_TREE); }
  2933.     | '&' type_quals new_declarator %prec EMPTY
  2934.         { $$ = make_reference_declarator ($2, $3); }
  2935.     | '&' type_quals %prec EMPTY
  2936.         { $$ = make_reference_declarator ($2, NULL_TREE); }
  2937.     | ptr_to_mem type_quals %prec EMPTY
  2938.         { tree arg = make_pointer_declarator ($2, NULL_TREE);
  2939.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2940.         }
  2941.     | ptr_to_mem type_quals new_declarator
  2942.         { tree arg = make_pointer_declarator ($2, $3);
  2943.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2944.         }
  2945.     | direct_new_declarator %prec EMPTY
  2946.     ;
  2947.  
  2948. /* ANSI direct-new-declarator (5.3.4) */
  2949. direct_new_declarator:
  2950.       '[' expr ']'
  2951.         { $$ = build_parse_node (ARRAY_REF, NULL_TREE, $2); }
  2952.     | direct_new_declarator '[' nonmomentary_expr ']'
  2953.         { $$ = build_parse_node (ARRAY_REF, $$, $3); }
  2954.     ;
  2955.  
  2956. /* ANSI abstract-declarator (8.1) */
  2957. absdcl:
  2958.       '*' nonempty_type_quals absdcl
  2959.         { $$ = make_pointer_declarator ($2, $3); }
  2960.     | '*' absdcl
  2961.         { $$ = make_pointer_declarator (NULL_TREE, $2); }
  2962.     | '*' nonempty_type_quals  %prec EMPTY
  2963.         { $$ = make_pointer_declarator ($2, NULL_TREE); }
  2964.     | '*' %prec EMPTY
  2965.         { $$ = make_pointer_declarator (NULL_TREE, NULL_TREE); }
  2966.     | '&' nonempty_type_quals absdcl
  2967.         { $$ = make_reference_declarator ($2, $3); }
  2968.     | '&' absdcl
  2969.         { $$ = make_reference_declarator (NULL_TREE, $2); }
  2970.     | '&' nonempty_type_quals %prec EMPTY
  2971.         { $$ = make_reference_declarator ($2, NULL_TREE); }
  2972.     | '&' %prec EMPTY
  2973.         { $$ = make_reference_declarator (NULL_TREE, NULL_TREE); }
  2974.     | ptr_to_mem type_quals %prec EMPTY
  2975.         { tree arg = make_pointer_declarator ($2, NULL_TREE);
  2976.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2977.         }
  2978.     | ptr_to_mem type_quals absdcl
  2979.         { tree arg = make_pointer_declarator ($2, $3);
  2980.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  2981.         }
  2982.     | direct_abstract_declarator %prec EMPTY
  2983.     ;
  2984.  
  2985. /* ANSI direct-abstract-declarator (8.1) */
  2986. direct_abstract_declarator:
  2987.       '(' absdcl ')'
  2988.         { $$ = $2; }
  2989.       /* `(typedef)1' is `int'.  */
  2990.     | PAREN_STAR_PAREN
  2991.     | direct_abstract_declarator '(' parmlist ')' type_quals  %prec '.'
  2992.         { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
  2993.     | direct_abstract_declarator LEFT_RIGHT type_quals  %prec '.'
  2994.         { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
  2995.     | direct_abstract_declarator '[' nonmomentary_expr ']'  %prec '.'
  2996.         { $$ = build_parse_node (ARRAY_REF, $$, $3); }
  2997.     | direct_abstract_declarator '[' ']'  %prec '.'
  2998.         { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
  2999.     | '(' complex_parmlist ')' type_quals  %prec '.'
  3000.         { $$ = build_parse_node (CALL_EXPR, NULL_TREE, $2, $4); }
  3001.     | regcast_or_absdcl type_quals %prec '.'
  3002.         { TREE_OPERAND ($$, 2) = $2; }
  3003.     | fcast_or_absdcl type_quals %prec '.'
  3004.         { TREE_OPERAND ($$, 2) = $2; }
  3005.     | '[' nonmomentary_expr ']'  %prec '.'
  3006.         { $$ = build_parse_node (ARRAY_REF, NULL_TREE, $2); }
  3007.     | '[' ']'  %prec '.'
  3008.         { $$ = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); }
  3009.     ;
  3010.  
  3011. /* For C++, decls and stmts can be intermixed, so we don't need to
  3012.    have a special rule that won't start parsing the stmt section
  3013.    until we have a stmt that parses without errors.  */
  3014.  
  3015. stmts:
  3016.       stmt
  3017.     | errstmt
  3018.     | stmts stmt
  3019.     | stmts errstmt
  3020.     ;
  3021.  
  3022. errstmt:  error ';'
  3023.     ;
  3024.  
  3025. /* build the LET_STMT node before parsing its contents,
  3026.   so that any LET_STMTs within the context can have their display pointers
  3027.   set up to point at this one.  */
  3028.  
  3029. .pushlevel:  /* empty */
  3030.         { emit_line_note (input_filename, lineno);
  3031.           pushlevel (0);
  3032.           clear_last_expr ();
  3033.           push_momentary ();
  3034.           expand_start_bindings (0); }
  3035.     ;
  3036.  
  3037. /* Read zero or more forward-declarations for labels
  3038.    that nested functions can jump to.  */
  3039. maybe_label_decls:
  3040.       /* empty */
  3041.     | label_decls
  3042.         { if (flag_ansi)
  3043.             pedwarn ("ANSI C++ forbids label declarations"); }
  3044.     ;
  3045.  
  3046. label_decls:
  3047.       label_decl
  3048.     | label_decls label_decl
  3049.     ;
  3050.  
  3051. label_decl:
  3052.       LABEL identifiers_or_typenames ';'
  3053.         { tree link;
  3054.           for (link = $2; link; link = TREE_CHAIN (link))
  3055.             {
  3056.               tree label = shadow_label (TREE_VALUE (link));
  3057.               C_DECLARED_LABEL_FLAG (label) = 1;
  3058.               declare_nonlocal_label (label);
  3059.             }
  3060.         }
  3061.     ;
  3062.  
  3063. /* This is the body of a function definition.
  3064.    It causes syntax errors to ignore to the next openbrace.  */
  3065. compstmt_or_error:
  3066.       compstmt
  3067.         {}
  3068.     | error compstmt
  3069.     ;
  3070.  
  3071. compstmt: '{' .pushlevel '}'
  3072.         { expand_end_bindings (getdecls (), kept_level_p(), 1);
  3073.           $$ = poplevel (kept_level_p (), 1, 0);
  3074.           pop_momentary (); }
  3075.     | '{' .pushlevel maybe_label_decls stmts '}'
  3076.         { expand_end_bindings (getdecls (), kept_level_p(), 1);
  3077.           $$ = poplevel (kept_level_p (), 1, 0);
  3078.           pop_momentary (); }
  3079.     | '{' .pushlevel maybe_label_decls stmts error '}'
  3080.         { expand_end_bindings (getdecls (), kept_level_p(), 1);
  3081.           $$ = poplevel (kept_level_p (), 0, 0);
  3082.           pop_momentary (); }
  3083.     | '{' .pushlevel maybe_label_decls error '}'
  3084.         { expand_end_bindings (getdecls (), kept_level_p(), 1);
  3085.           $$ = poplevel (kept_level_p (), 0, 0);
  3086.           pop_momentary (); }
  3087.     ;
  3088.  
  3089. simple_if:
  3090.       IF
  3091.         { cond_stmt_keyword = "if"; }
  3092.       .pushlevel paren_cond_or_null
  3093.         { emit_line_note (input_filename, lineno);
  3094.           expand_start_cond ($4, 0); }
  3095.       implicitly_scoped_stmt
  3096.     ;
  3097.  
  3098. implicitly_scoped_stmt:
  3099.       compstmt
  3100.         { finish_stmt (); }
  3101.     | .pushlevel simple_stmt
  3102.         { expand_end_bindings (getdecls (), kept_level_p (), 1);
  3103.           $$ = poplevel (kept_level_p (), 1, 0);
  3104.           pop_momentary (); }
  3105.     ;
  3106.  
  3107. stmt:
  3108.       compstmt
  3109.         { finish_stmt (); }
  3110.     | simple_stmt
  3111.     ;
  3112.  
  3113. simple_stmt:
  3114.       decl
  3115.         { finish_stmt (); }
  3116.     | expr ';'
  3117.         {
  3118.           tree expr = $1;
  3119.           emit_line_note (input_filename, lineno);
  3120.           /* Do default conversion if safe and possibly important,
  3121.              in case within ({...}).  */
  3122.           if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
  3123.                && lvalue_p (expr))
  3124.               || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
  3125.             expr = default_conversion (expr);
  3126.           cplus_expand_expr_stmt (expr);
  3127.           clear_momentary ();
  3128.           finish_stmt (); }
  3129.     | simple_if ELSE
  3130.         { expand_start_else (); }
  3131.       implicitly_scoped_stmt
  3132.         { expand_end_cond ();
  3133.           expand_end_bindings (getdecls (), kept_level_p (), 1);
  3134.           poplevel (kept_level_p (), 1, 0);
  3135.           pop_momentary ();
  3136.           finish_stmt (); }
  3137.     | simple_if %prec IF
  3138.         { expand_end_cond ();
  3139.           expand_end_bindings (getdecls (), kept_level_p (), 1);
  3140.           poplevel (kept_level_p (), 1, 0);
  3141.           pop_momentary ();
  3142.           finish_stmt (); }
  3143.     | WHILE
  3144.         { emit_nop ();
  3145.           emit_line_note (input_filename, lineno);
  3146.           expand_start_loop (1);
  3147.           cond_stmt_keyword = "while"; }
  3148.       .pushlevel paren_cond_or_null
  3149.         { expand_exit_loop_if_false (0, $4); }
  3150.       already_scoped_stmt
  3151.         { expand_end_bindings (getdecls (), kept_level_p (), 1);
  3152.           poplevel (kept_level_p (), 1, 0);
  3153.           pop_momentary ();
  3154.           expand_end_loop ();
  3155.           finish_stmt (); }
  3156.     | DO
  3157.         { emit_nop ();
  3158.           emit_line_note (input_filename, lineno);
  3159.           expand_start_loop_continue_elsewhere (1); }
  3160.       implicitly_scoped_stmt WHILE
  3161.         { expand_loop_continue_here ();
  3162.           cond_stmt_keyword = "do"; }
  3163.       paren_expr_or_null ';'
  3164.         { emit_line_note (input_filename, lineno);
  3165.           expand_exit_loop_if_false (0, $6);
  3166.           expand_end_loop ();
  3167.           clear_momentary ();
  3168.           finish_stmt (); }
  3169.     | forhead.1
  3170.         { emit_nop ();
  3171.           emit_line_note (input_filename, lineno);
  3172.           if ($1) cplus_expand_expr_stmt ($1);
  3173.           expand_start_loop_continue_elsewhere (1); }
  3174.       .pushlevel xcond ';'
  3175.         { emit_line_note (input_filename, lineno);
  3176.           if ($4) expand_exit_loop_if_false (0, $4); }
  3177.       xexpr ')'
  3178.         /* Don't let the tree nodes for $7 be discarded
  3179.            by clear_momentary during the parsing of the next stmt.  */
  3180.         { push_momentary (); }
  3181.       already_scoped_stmt
  3182.         { emit_line_note (input_filename, lineno);
  3183.           expand_end_bindings (getdecls (), kept_level_p (), 1);
  3184.           poplevel (kept_level_p (), 1, 0);
  3185.           pop_momentary ();
  3186.           expand_loop_continue_here ();
  3187.           if ($7) cplus_expand_expr_stmt ($7);
  3188.           pop_momentary ();
  3189.           expand_end_loop ();
  3190.           finish_stmt (); }
  3191.     | forhead.2
  3192.         { emit_nop ();
  3193.           emit_line_note (input_filename, lineno);
  3194.           expand_start_loop_continue_elsewhere (1); }
  3195.       .pushlevel xcond ';'
  3196.         { emit_line_note (input_filename, lineno);
  3197.           if ($4) expand_exit_loop_if_false (0, $4); }
  3198.       xexpr ')'
  3199.         /* Don't let the tree nodes for $7 be discarded
  3200.            by clear_momentary during the parsing of the next stmt.  */
  3201.         { push_momentary ();
  3202.           $<itype>8 = lineno; }
  3203.       already_scoped_stmt
  3204.         { emit_line_note (input_filename, (int) $<itype>8);
  3205.           expand_end_bindings (getdecls (), kept_level_p (), 1);
  3206.           poplevel (kept_level_p (), 1, 0);
  3207.           pop_momentary ();
  3208.           expand_loop_continue_here ();
  3209.           if ($7) cplus_expand_expr_stmt ($7);
  3210.           pop_momentary ();
  3211.           expand_end_loop ();
  3212.           finish_stmt ();
  3213.         }
  3214.     | SWITCH .pushlevel '(' condition ')'
  3215.         { emit_line_note (input_filename, lineno);
  3216.           c_expand_start_case ($4);
  3217.           /* Don't let the tree nodes for $4 be discarded by
  3218.              clear_momentary during the parsing of the next stmt.  */
  3219.           push_momentary (); }
  3220.       implicitly_scoped_stmt
  3221.         { expand_end_case ($4);
  3222.           pop_momentary ();
  3223.           expand_end_bindings (getdecls (), kept_level_p (), 1);
  3224.           poplevel (kept_level_p (), 1, 0);
  3225.           pop_momentary ();
  3226.           finish_stmt (); }
  3227.     | CASE expr_no_commas ':'
  3228.         { register tree value = check_cp_case_value ($2);
  3229.           register tree label
  3230.             = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
  3231.  
  3232.           if (value != error_mark_node)
  3233.             {
  3234.               tree duplicate;
  3235.               int success = pushcase (value, convert_and_check,
  3236.                           label, &duplicate);
  3237.               if (success == 1)
  3238.             cp_error ("case label `%E' not within a switch statement", $2);
  3239.               else if (success == 2)
  3240.             {
  3241.               cp_error ("duplicate case value `%E'", $2);
  3242.               cp_error_at ("`%E' previously used here", duplicate);
  3243.             }
  3244.               else if (success == 3)
  3245.             warning ("case value out of range");
  3246.               else if (success == 5)
  3247.             cp_error ("case label `%E' within scope of cleanup or variable array", $2);
  3248.             }
  3249.           define_case_label (label);
  3250.         }
  3251.       stmt
  3252.     | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
  3253.         { register tree value1 = check_cp_case_value ($2);
  3254.           register tree value2 = check_cp_case_value ($4);
  3255.           register tree label
  3256.             = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
  3257.  
  3258.           if (flag_ansi)
  3259.             pedwarn ("ANSI C++ forbids range expressions in switch statement");
  3260.           if (value1 != error_mark_node
  3261.               && value2 != error_mark_node)
  3262.             {
  3263.               tree duplicate;
  3264.               int success = pushcase_range (value1, value2,
  3265.                             convert_and_check, label,
  3266.                             &duplicate);
  3267.               if (success == 1)
  3268.             error ("case label not within a switch statement");
  3269.               else if (success == 2)
  3270.             {
  3271.               error ("duplicate (or overlapping) case value");
  3272.               error_with_decl (duplicate, "this is the first entry overlapping that value");
  3273.             }
  3274.               else if (success == 3)
  3275.             warning ("case value out of range");
  3276.               else if (success == 4)
  3277.             warning ("empty range specified");
  3278.               else if (success == 5)
  3279.             error ("case label within scope of cleanup or variable array");
  3280.             }
  3281.           define_case_label (label);
  3282.         }
  3283.       stmt
  3284.     | DEFAULT ':'
  3285.         {
  3286.           tree duplicate;
  3287.           register tree label
  3288.             = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
  3289.           int success = pushcase (NULL_TREE, 0, label, &duplicate);
  3290.           if (success == 1)
  3291.             error ("default label not within a switch statement");
  3292.           else if (success == 2)
  3293.             {
  3294.               error ("multiple default labels in one switch");
  3295.               error_with_decl (duplicate, "this is the first default label");
  3296.             }
  3297.           define_case_label (NULL_TREE);
  3298.         }
  3299.       stmt
  3300.     | BREAK ';'
  3301.         { emit_line_note (input_filename, lineno);
  3302.           if ( ! expand_exit_something ())
  3303.             error ("break statement not within loop or switch"); }
  3304.     | CONTINUE ';'
  3305.         { emit_line_note (input_filename, lineno);
  3306.           if (! expand_continue_loop (0))
  3307.             error ("continue statement not within a loop"); }
  3308.     | RETURN ';'
  3309.         { emit_line_note (input_filename, lineno);
  3310.           c_expand_return (NULL_TREE); }
  3311.     | RETURN expr ';'
  3312.         { emit_line_note (input_filename, lineno);
  3313.           c_expand_return ($2);
  3314.           finish_stmt ();
  3315.         }
  3316.     | asm_keyword maybe_type_qual '(' string ')' ';'
  3317.         { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
  3318.           emit_line_note (input_filename, lineno);
  3319.           expand_asm ($4);
  3320.           finish_stmt ();
  3321.         }
  3322.     /* This is the case with just output operands.  */
  3323.     | asm_keyword maybe_type_qual '(' string ':' asm_operands ')' ';'
  3324.         { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
  3325.           emit_line_note (input_filename, lineno);
  3326.           c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
  3327.                      $2 == ridpointers[(int)RID_VOLATILE],
  3328.                      input_filename, lineno);
  3329.           finish_stmt ();
  3330.         }
  3331.     /* This is the case with input operands as well.  */
  3332.     | asm_keyword maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';'
  3333.         { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
  3334.           emit_line_note (input_filename, lineno);
  3335.           c_expand_asm_operands ($4, $6, $8, NULL_TREE,
  3336.                      $2 == ridpointers[(int)RID_VOLATILE],
  3337.                      input_filename, lineno);
  3338.           finish_stmt ();
  3339.         }
  3340.     /* This is the case with clobbered registers as well.  */
  3341.     | asm_keyword maybe_type_qual '(' string ':' asm_operands ':'
  3342.       asm_operands ':' asm_clobbers ')' ';'
  3343.         { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
  3344.           emit_line_note (input_filename, lineno);
  3345.           c_expand_asm_operands ($4, $6, $8, $10,
  3346.                      $2 == ridpointers[(int)RID_VOLATILE],
  3347.                      input_filename, lineno);
  3348.           finish_stmt ();
  3349.         }
  3350.     | GOTO '*' expr ';'
  3351.         { emit_line_note (input_filename, lineno);
  3352.           expand_computed_goto ($3); }
  3353.     | GOTO identifier ';'
  3354.         { tree decl;
  3355.           emit_line_note (input_filename, lineno);
  3356.           decl = lookup_label ($2);
  3357.           TREE_USED (decl) = 1;
  3358.           expand_goto (decl); }
  3359.     | label_colon stmt
  3360.         { finish_stmt (); }
  3361.     | label_colon '}'
  3362.         { error ("label must be followed by statement");
  3363.           yyungetc ('}', 0);
  3364.           finish_stmt (); }
  3365.     | ';'
  3366.         { finish_stmt (); }
  3367.     | try_block
  3368.     ;
  3369.  
  3370. try_block:
  3371.       TRY '{' .pushlevel
  3372.         { expand_start_try_stmts (); }
  3373.       ansi_try_stmts
  3374.         { expand_end_try_stmts ();
  3375.           expand_start_all_catch (); }
  3376.       handler_seq
  3377.         { expand_end_all_catch (); }
  3378.     ;
  3379.  
  3380. ansi_try_stmts:
  3381.       '}'
  3382.         /* An empty try block is degenerate, but it's better to
  3383.            do extra work here than to do all the special-case work
  3384.            everywhere else.  */
  3385.         { expand_end_bindings (0,1,1);
  3386.           poplevel (2,0,0);
  3387.         }
  3388.     | stmts '}'
  3389.         { expand_end_bindings (0,1,1);
  3390.           poplevel (2,0,0);
  3391.         }
  3392.     | error '}'
  3393.         { expand_end_bindings (0,1,1);
  3394.           poplevel (2,0,0);
  3395.         }
  3396.     ;
  3397.  
  3398. handler_seq:
  3399.       /* empty */
  3400.     | handler_seq CATCH
  3401.         { emit_line_note (input_filename, lineno); }
  3402.       handler_args compstmt
  3403.         { expand_end_catch_block (); }
  3404.     ;
  3405.  
  3406. type_specifier_seq:
  3407.       typed_typespecs %prec EMPTY
  3408.     | nonempty_type_quals %prec EMPTY
  3409.     ;
  3410.  
  3411. handler_args:
  3412.       '(' ELLIPSIS ')'
  3413.         { expand_start_catch_block (NULL_TREE, NULL_TREE); }
  3414.     /* This doesn't allow reference parameters, the below does.
  3415.     | '(' type_specifier_seq absdcl ')'
  3416.         { expand_start_catch_block ($2, $3); }
  3417.     | '(' type_specifier_seq ')'
  3418.         { expand_start_catch_block ($2, NULL_TREE); }
  3419.     | '(' type_specifier_seq notype_declarator ')'
  3420.         { expand_start_catch_block ($2, $3); }
  3421.     | '(' typed_typespecs after_type_declarator ')'
  3422.         { expand_start_catch_block ($2, $3); }
  3423.     */
  3424.     | '(' parm ')'
  3425.         { expand_start_catch_block (TREE_PURPOSE ($2),
  3426.                         TREE_VALUE ($2)); }
  3427.     ;
  3428.  
  3429. label_colon:
  3430.       IDENTIFIER ':'
  3431.         { tree label;
  3432.         do_label:
  3433.           label = define_label (input_filename, lineno, $1);
  3434.           if (label)
  3435.             expand_label (label);
  3436.         }
  3437.     | PTYPENAME ':'
  3438.         { goto do_label; }
  3439.     | TYPENAME ':'
  3440.         { goto do_label; }
  3441.     ;
  3442.  
  3443. forhead.1:
  3444.       FOR '(' ';'
  3445.         { $$ = NULL_TREE; }
  3446.     | FOR '(' expr ';'
  3447.         { $$ = $3; }
  3448.     | FOR '(' '{' '}'
  3449.         { $$ = NULL_TREE; }
  3450.     ;
  3451.  
  3452. forhead.2:
  3453.       FOR '(' decl
  3454.         { $$ = 0; }
  3455.     | FOR '(' error ';'
  3456.         { $$ = 0; }
  3457.     | FOR '(' '{' .pushlevel stmts '}'
  3458.         { $$ = 1; }
  3459.     | FOR '(' '{' .pushlevel error '}'
  3460.         { $$ = -1; }
  3461.     ;
  3462.  
  3463. /* Either a type-qualifier or nothing.  First thing in an `asm' statement.  */
  3464.  
  3465. maybe_type_qual:
  3466.     /* empty */
  3467.         { emit_line_note (input_filename, lineno);
  3468.           $$ = NULL_TREE; }
  3469.     | TYPE_QUAL
  3470.         { emit_line_note (input_filename, lineno); }
  3471.     ;
  3472.  
  3473. xexpr:
  3474.     /* empty */
  3475.         { $$ = NULL_TREE; }
  3476.     | expr
  3477.     | error
  3478.         { $$ = NULL_TREE; }
  3479.     ;
  3480.  
  3481. /* These are the operands other than the first string and colon
  3482.    in  asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x))  */
  3483. asm_operands: /* empty */
  3484.         { $$ = NULL_TREE; }
  3485.     | nonnull_asm_operands
  3486.     ;
  3487.  
  3488. nonnull_asm_operands:
  3489.       asm_operand
  3490.     | nonnull_asm_operands ',' asm_operand
  3491.         { $$ = chainon ($$, $3); }
  3492.     ;
  3493.  
  3494. asm_operand:
  3495.       STRING '(' expr ')'
  3496.         { $$ = build_tree_list ($$, $3); }
  3497.     ;
  3498.  
  3499. asm_clobbers:
  3500.       STRING
  3501.         { $$ = tree_cons (NULL_TREE, $$, NULL_TREE); }
  3502.     | asm_clobbers ',' STRING
  3503.         { $$ = tree_cons (NULL_TREE, $3, $$); }
  3504.     ;
  3505.  
  3506. /* This is what appears inside the parens in a function declarator.
  3507.    Its value is represented in the format that grokdeclarator expects.
  3508.  
  3509.    In C++, declaring a function with no parameters
  3510.    means that that function takes *no* parameters.  */
  3511.  
  3512. parmlist:  /* empty */
  3513.         {
  3514.           if (strict_prototype)
  3515.             $$ = void_list_node;
  3516.           else
  3517.             $$ = NULL_TREE;
  3518.         }
  3519.     | complex_parmlist
  3520.     | type_id
  3521.         { $$ = tree_cons (NULL_TREE, $$, void_list_node);
  3522.           TREE_PARMLIST ($$) = 1; }
  3523.     ;
  3524.  
  3525. /* This nonterminal does not include the common sequence '(' type_id ')',
  3526.    as it is ambiguous and must be disambiguated elsewhere.  */
  3527. complex_parmlist:
  3528.       parms
  3529.         {
  3530.           $$ = chainon ($$, void_list_node);
  3531.           TREE_PARMLIST ($$) = 1;
  3532.         }
  3533.     | parms_comma ELLIPSIS
  3534.         {
  3535.           TREE_PARMLIST ($$) = 1;
  3536.         }
  3537.     /* C++ allows an ellipsis without a separating ',' */
  3538.     | parms ELLIPSIS
  3539.         {
  3540.           TREE_PARMLIST ($$) = 1;
  3541.         }
  3542.     | type_id ELLIPSIS
  3543.         {
  3544.           $$ = build_tree_list (NULL_TREE, $$); 
  3545.           TREE_PARMLIST ($$) = 1;
  3546.         }
  3547.     | ELLIPSIS
  3548.         {
  3549.           /* ARM $8.2.5 has this as a boxed-off comment.  */
  3550.           if (pedantic)
  3551.             warning ("use of `...' without a first argument is non-portable");
  3552.           $$ = NULL_TREE;
  3553.         }
  3554.     | TYPENAME_ELLIPSIS
  3555.         {
  3556.           TREE_PARMLIST ($$) = 1;
  3557.         }
  3558.     | parms TYPENAME_ELLIPSIS
  3559.         {
  3560.           TREE_PARMLIST ($$) = 1;
  3561.         }
  3562.     | type_id TYPENAME_ELLIPSIS
  3563.         {
  3564.           $$ = build_tree_list (NULL_TREE, $$);
  3565.           TREE_PARMLIST ($$) = 1;
  3566.         }
  3567.     | parms ':'
  3568.         {
  3569.           /* This helps us recover from really nasty
  3570.              parse errors, for example, a missing right
  3571.              parenthesis.  */
  3572.           yyerror ("possibly missing ')'");
  3573.           $$ = chainon ($$, void_list_node);
  3574.           TREE_PARMLIST ($$) = 1;
  3575.           yyungetc (':', 0);
  3576.           yychar = ')';
  3577.         }
  3578.     | type_id ':'
  3579.         {
  3580.           /* This helps us recover from really nasty
  3581.              parse errors, for example, a missing right
  3582.              parenthesis.  */
  3583.           yyerror ("possibly missing ')'");
  3584.           $$ = tree_cons (NULL_TREE, $$, void_list_node);
  3585.           TREE_PARMLIST ($$) = 1;
  3586.           yyungetc (':', 0);
  3587.           yychar = ')';
  3588.         }
  3589.     ;
  3590.  
  3591. /* A nonempty list of parameter declarations or type names.  */
  3592. parms:
  3593.       named_parm
  3594.         { $$ = build_tree_list (NULL_TREE, $$); }
  3595.     | parm '=' init
  3596.         { $$ = build_tree_list ($3, $$); }
  3597.     | parms_comma full_parm
  3598.         { $$ = chainon ($$, $2); }
  3599.     | parms_comma bad_parm
  3600.         { $$ = chainon ($$, build_tree_list (NULL_TREE, $2)); }
  3601.     | parms_comma bad_parm '=' init
  3602.         { $$ = chainon ($$, build_tree_list ($4, $2)); }
  3603.     ;
  3604.  
  3605. parms_comma:
  3606.       parms ','
  3607.     | type_id ','
  3608.         { $$ = build_tree_list (NULL_TREE, $$); }
  3609.     ;
  3610.  
  3611. /* A single parameter declaration or parameter type name,
  3612.    as found in a parmlist.  The first four cases make up for 10%
  3613.    of the time spent parsing C++.  We cannot use them because
  3614.    of `int id[]' which won't get parsed properly.  */
  3615. named_parm:
  3616. /*
  3617.       typed_declspecs dont_see_typename '*' IDENTIFIER
  3618.         { $$ = build_tree_list ($$, build_parse_node (INDIRECT_REF, $4));
  3619.           see_typename (); }
  3620.     | typed_declspecs dont_see_typename '&' IDENTIFIER
  3621.         { $$ = build_tree_list ($$, build_parse_node (ADDR_EXPR, $4));
  3622.           see_typename (); }
  3623.     | TYPENAME IDENTIFIER
  3624.         { $$ = build_tree_list (get_decl_list ($$), $2);  }
  3625.     | TYPESPEC IDENTIFIER
  3626.         { $$ = build_tree_list (get_decl_list ($$), $2); }
  3627.     | */
  3628.     /* Here we expand typed_declspecs inline to avoid mis-parsing of
  3629.        TYPESPEC IDENTIFIER.  */
  3630.       typed_declspecs1 declarator
  3631.         { $$ = build_tree_list ($$, $2); }
  3632.     | typed_typespecs declarator
  3633.         { $$ = build_tree_list ($$, $2); }
  3634.     | typespec declarator
  3635.         { $$ = build_tree_list (get_decl_list ($$), $2); }
  3636.     | typed_declspecs1 absdcl
  3637.         { $$ = build_tree_list ($$, $2); }
  3638.     | typed_declspecs1 %prec EMPTY
  3639.         { $$ = build_tree_list ($$, NULL_TREE); }
  3640.     | declmods notype_declarator
  3641.         { $$ = build_tree_list ($$, $2); }
  3642.     ;
  3643.  
  3644. full_parm:
  3645.       parm
  3646.         { $$ = build_tree_list (NULL_TREE, $$); }
  3647.     | parm '=' init
  3648.         { $$ = build_tree_list ($3, $$); }
  3649.     ;
  3650.  
  3651. parm:
  3652.     named_parm
  3653.     | type_id
  3654.     ;
  3655.  
  3656. see_typename: %prec EMPTY
  3657.     { see_typename (); }
  3658.     ;
  3659.  
  3660. /* 
  3661. dont_see_typename: %prec EMPTY
  3662.     { dont_see_typename (); }
  3663.     ; 
  3664.  
  3665. try_for_typename:
  3666.         {
  3667.       if ($<ttype>-1 == error_mark_node)
  3668.             $$ = 0;
  3669.           else
  3670.             {
  3671.               $$ = 1;
  3672.               pushclass ($<ttype>-1, 1);
  3673.             }
  3674.         }
  3675.     ;
  3676. */
  3677.  
  3678. bad_parm:
  3679.       /* empty */ %prec EMPTY
  3680.         {
  3681.           warning ("type specifier omitted for parameter");
  3682.           $$ = build_tree_list (TREE_PURPOSE (TREE_VALUE ($<ttype>-1)), NULL_TREE);
  3683.         }
  3684.     | notype_declarator
  3685.         {
  3686.           warning ("type specifier omitted for parameter");
  3687.           $$ = build_tree_list (TREE_PURPOSE (TREE_VALUE ($<ttype>-1)), $$);
  3688.         }
  3689.     ;
  3690.  
  3691. maybe_raises:
  3692.       %prec EMPTY /* empty */
  3693.         { $$ = NULL_TREE; }
  3694.     | THROW '(' ansi_raise_identifiers  ')' %prec EMPTY
  3695.         { $$ = $3; }
  3696.     ;
  3697.  
  3698. ansi_raise_identifier:
  3699.       type_id
  3700.         { $$ = build_decl_list (NULL_TREE, $$); }
  3701.     ;
  3702.  
  3703. ansi_raise_identifiers:
  3704.       ansi_raise_identifier
  3705.     | ansi_raise_identifiers ',' ansi_raise_identifier
  3706.         {
  3707.           TREE_CHAIN ($3) = $$;
  3708.           $$ = $3;
  3709.         }
  3710.     ;
  3711.  
  3712. conversion_declarator:
  3713.       /* empty */ %prec EMPTY
  3714.         { $$ = NULL_TREE; }
  3715.     | '*' type_quals conversion_declarator
  3716.         { $$ = make_pointer_declarator ($2, $3); }
  3717.     | '&' type_quals conversion_declarator
  3718.         { $$ = make_reference_declarator ($2, $3); }
  3719.     | ptr_to_mem type_quals conversion_declarator
  3720.         { tree arg = make_pointer_declarator ($2, $3);
  3721.           $$ = build_parse_node (SCOPE_REF, $1, arg);
  3722.         }
  3723.     ;
  3724.  
  3725. operator: OPERATOR
  3726.         { got_scope = NULL_TREE; }
  3727.     ;
  3728.  
  3729. operator_name:
  3730.       operator '*'
  3731.         { $$ = ansi_opname[MULT_EXPR]; }
  3732.     | operator '/'
  3733.         { $$ = ansi_opname[TRUNC_DIV_EXPR]; }
  3734.     | operator '%'
  3735.         { $$ = ansi_opname[TRUNC_MOD_EXPR]; }
  3736.     | operator '+'
  3737.         { $$ = ansi_opname[PLUS_EXPR]; }
  3738.     | operator '-'
  3739.         { $$ = ansi_opname[MINUS_EXPR]; }
  3740.     | operator '&'
  3741.         { $$ = ansi_opname[BIT_AND_EXPR]; }
  3742.     | operator '|'
  3743.         { $$ = ansi_opname[BIT_IOR_EXPR]; }
  3744.     | operator '^'
  3745.         { $$ = ansi_opname[BIT_XOR_EXPR]; }
  3746.     | operator '~'
  3747.         { $$ = ansi_opname[BIT_NOT_EXPR]; }
  3748.     | operator ','
  3749.         { $$ = ansi_opname[COMPOUND_EXPR]; }
  3750.     | operator ARITHCOMPARE
  3751.         { $$ = ansi_opname[$2]; }
  3752.     | operator '<'
  3753.         { $$ = ansi_opname[LT_EXPR]; }
  3754.     | operator '>'
  3755.         { $$ = ansi_opname[GT_EXPR]; }
  3756.     | operator EQCOMPARE
  3757.         { $$ = ansi_opname[$2]; }
  3758.     | operator ASSIGN
  3759.         { $$ = ansi_assopname[$2]; }
  3760.     | operator '='
  3761.         { $$ = ansi_opname [MODIFY_EXPR]; }
  3762.     | operator LSHIFT
  3763.         { $$ = ansi_opname[$2]; }
  3764.     | operator RSHIFT
  3765.         { $$ = ansi_opname[$2]; }
  3766.     | operator PLUSPLUS
  3767.         { $$ = ansi_opname[POSTINCREMENT_EXPR]; }
  3768.     | operator MINUSMINUS
  3769.         { $$ = ansi_opname[PREDECREMENT_EXPR]; }
  3770.     | operator ANDAND
  3771.         { $$ = ansi_opname[TRUTH_ANDIF_EXPR]; }
  3772.     | operator OROR
  3773.         { $$ = ansi_opname[TRUTH_ORIF_EXPR]; }
  3774.     | operator '!'
  3775.         { $$ = ansi_opname[TRUTH_NOT_EXPR]; }
  3776.     | operator '?' ':'
  3777.         { $$ = ansi_opname[COND_EXPR]; }
  3778.     | operator MIN_MAX
  3779.         { $$ = ansi_opname[$2]; }
  3780.     | operator POINTSAT  %prec EMPTY
  3781.         { $$ = ansi_opname[COMPONENT_REF]; }
  3782.     | operator POINTSAT_STAR  %prec EMPTY
  3783.         { $$ = ansi_opname[MEMBER_REF]; }
  3784.     | operator LEFT_RIGHT
  3785.         { $$ = ansi_opname[CALL_EXPR]; }
  3786.     | operator '[' ']'
  3787.         { $$ = ansi_opname[ARRAY_REF]; }
  3788.     | operator NEW %prec EMPTY
  3789.         { $$ = ansi_opname[NEW_EXPR]; }
  3790.     | operator DELETE %prec EMPTY
  3791.         { $$ = ansi_opname[DELETE_EXPR]; }
  3792.     | operator NEW '[' ']'
  3793.         { $$ = ansi_opname[VEC_NEW_EXPR]; }
  3794.     | operator DELETE '[' ']'
  3795.         { $$ = ansi_opname[VEC_DELETE_EXPR]; }
  3796.     /* Names here should be looked up in class scope ALSO.  */
  3797.     | operator type_specifier_seq conversion_declarator
  3798.         { $$ = grokoptypename ($2, $3); }
  3799.     | operator error
  3800.         { $$ = ansi_opname[ERROR_MARK]; }
  3801.     ;
  3802.  
  3803. %%
  3804.  
  3805. #ifdef SPEW_DEBUG
  3806. const char *
  3807. debug_yytranslate (value)
  3808.     int value;
  3809. {
  3810.   return yytname[YYTRANSLATE (value)];
  3811. }
  3812.  
  3813. #endif
  3814.